Do SRE interviews include coding rounds?

Often, and the depth depends on which SRE variant the team runs. Some SRE loops, the software-leaning track at large infrastructure companies being the best known example, include a standard algorithms round graded on the software engineering bar. Others replace it with a scripting exercise: parse a log stream, call an API with retries and backoff, or write an idempotent cleanup script. The posting usually gives it away, since one version lists data structures and the other lists Python or Go for automation.

What is an error budget and how is it calculated in an interview?

An error budget is the amount of unreliability an SLO permits. For a 99.9 percent availability target over a 30-day month there are 43,200 minutes in the window, so the budget is 0.1 percent of that, 43.2 minutes. At 99.95 percent it is 21.6 minutes and at 99.99 percent it is 4.32 minutes. Request-based SLOs work identically: 10 million requests at 99.9 percent permits 10,000 failures.

How do I tell from a job description whether I will get a DevOps or an SRE loop?

Ignore the tool list, because Kubernetes, Docker and Terraform appear in both. Read the verbs instead. Build, automate, enable, streamline and self-service predict a DevOps or platform loop with a pipeline design round. Operate, measure, defend, respond, reduce toil and on-call rotation predict an SRE loop with SLO maths and an incident scenario. A posting that names an error budget almost always runs the SRE version.

Do DevOps interviews ask about Linux namespaces and cgroups?

Frequently, usually as a follow-up rather than as a definition question. The expected answer is that a container is an ordinary Linux process with namespaces limiting what it can see, pid, net, mnt, uts, ipc and user among them, and cgroups limiting what it can consume. A common probe is why a container exits with code 137, which is 128 plus signal 9, meaning the kernel killed it at the cgroup memory limit.

Can an AI interview copilot help in a DevOps or SRE interview?

It helps in the spoken rounds, where a prompt restores a definition or a structure you already knew, and in behavioural and postmortem discussions. It helps least in the live troubleshooting round, where you are typing into a shared terminal and the interviewer is watching your commands rather than listening for a definition. OfferPilot AI runs on Windows 10 and 11 only, and its capture exclusion hides the overlay from screen sharing, not from a webcam or a proctor.

DevOps Interview vs SRE Interview: Two Different Question Sets

Q: What is the difference between a DevOps interview and an SRE interview?

A DevOps loop tests how you build and ship: CI/CD pipeline design, infrastructure as code, and container and Linux internals such as namespaces and cgroups. An SRE loop tests how you run things under a reliability contract: SLO and error budget arithmetic, incident command, and a live troubleshooting round on a deliberately broken system. Both postings mention Kubernetes and Terraform, but the two loops grade different answers to the same question.

A DevOps loop interrogates how software gets built and shipped: pipeline design, infrastructure as code, and container internals down to namespaces and cgroups. An SRE loop interrogates how a running system is held to a reliability contract: SLO and error budget arithmetic, incident command, and a live troubleshooting round on a box someone has deliberately broken. The two postings look almost identical, because both list Kubernetes, Terraform and Prometheus. The interviews overlap far less than the tool lists suggest, and the wording of the job description predicts which one you will get.

The two question sets, side by side

Seven round types cover nearly every loop in either family. The difference is which of them appear, and which one carries the levelling decision.

Round	DevOps and platform loop	SRE loop
CI/CD pipeline design	Very common, often the deciding round. Build once and promote the same artefact, caching, ephemeral runners, secret injection, monorepo change detection, signed artefacts.	Uncommon as a round. May surface as one question about safe rollout and rollback.
Infrastructure as code	Very common. State backends and locking, drift, importing existing resources, module boundaries, why `for_each` beats `count` when a list element is removed, plan review run as a code review exercise.	Sometimes, and shallower. Usually one question about whether a change is reversible under pressure.
Container and Linux internals	Common, follow-up style. Namespaces, cgroup limits, image layers, exit codes, what happens between `kubectl apply` and a pod passing readiness.	Common but aimed differently: the same internals as a debugging instrument rather than as a design topic.
Live troubleshooting	Occasional, usually a broken pipeline or a pod stuck in `CrashLoopBackOff`.	Nearly always, and typically the round that decides the offer. A shared terminal, a real fault, and you narrating hypotheses out loud.
SLO, SLI and error budget	Rare, and treated as vocabulary when it appears.	Nearly always, with arithmetic. You will be asked to pick an SLI, defend a target, and do the budget sum in your head.
Incident command roleplay	Rare.	Common at mid level and above. A pager fires, the interviewer plays the system, and you are graded on the questions you ask and on how you separate mitigation from diagnosis.
Coding	Scripting and tooling. Write something idempotent, parse structured logs, wrap an API with retries.	Split by track. Software-leaning SRE roles run a genuine algorithms round on the engineering bar. Systems-leaning roles replace it with the same scripting exercise.

The structural point behind the table: a DevOps loop asks what you would build, an SRE loop asks what you would do while it is on fire. Candidates who arrive at an SRE loop with architecture diagrams get caught out in the incident round, because nobody wants a diagram. They want to know what you check first and what you would be willing to break to stop the bleeding.

The job-description decoder

The tool list is noise. Kubernetes, Docker, Terraform, Prometheus and Grafana appear in both families and predict nothing at all. What predicts the loop is the verbs and the accountability language.

Wording in the posting	Loop it predicts	What to rehearse
"Enable engineering teams", "self-service", "golden paths", "internal developer platform", "reduce build times", "improve developer experience"	DevOps or platform	Pipeline design end to end, artefact promotion, module design in Terraform
"Own and defend SLOs", "error budget", "reduce toil", "lower MTTR", "capacity planning", "blameless postmortem"	SRE	Budget arithmetic, burn-rate alerting, one postmortem you can narrate from memory
"Participate in a 24/7 on-call rotation", especially with a compensation or paging clause attached	SRE, almost certainly with an incident roleplay	Incident command: roles, comms, mitigate before you diagnose
"Deep Linux internals", "kernel", "TCP/IP", "performance tuning"	Systems-leaning SRE	A live debug round in a shared terminal
"Data structures and algorithms", or a named online coding screen in the process description	Software-leaning SRE	A real algorithms round, same bar as a backend loop
"Python or Go for automation and tooling", with no algorithms mention anywhere	Either family, scripting round	Idempotency, retries with backoff, log parsing, exit codes
"Kubernetes, Terraform, Docker, CI/CD" and nothing else concrete	Undetermined	Ask the recruiter which rounds are on the schedule

Two secondary signals are worth ten seconds each. Who the role reports to: a platform or developer productivity team writes the build loop, a central reliability organisation writes the SLO loop. And whether the posting describes the systems you would own or the teams you would serve. "You will own the availability of the checkout path" and "you will support twelve product teams" produce different interviews, written by different people.

The error budget question, worked

This is the round DevOps candidates lose most often, and it is unforgiving because the numbers are checkable. A 30-day month contains 43,200 minutes. The budget is whatever the SLO gives away:

99.9 percent leaves 43.2 minutes of unavailability in the month.
99.95 percent leaves 21.6 minutes.
99.99 percent leaves 4.32 minutes, which is less time than most manual rollbacks take, so any credible answer at that target has to include automated mitigation.

Request-based SLOs behave the same way and are usually the better choice for a request-serving system: 10 million requests a month at 99.9 percent success permits 10,000 failures, so an incident that fails 2,000 requests has spent a fifth of the month's budget in one go. Say that number out loud. It is the moment the interviewer stops checking whether you have memorised a definition.

The follow-up is almost always burn rate, which is how fast you are spending relative to the budget lasting exactly one window. Consuming 2 percent of a 30-day budget inside a single hour is a burn rate of roughly 14.4, because one hour is about a 720th of the window. That is the standard fast-burn page. A slower companion condition, in the region of 5 percent of the budget over six hours, catches the degradations that never trip the fast alert but would still exhaust the month. Explaining why two windows exist, one for precision and one to avoid missing a slow leak, separates people who have run an SLO from people who have read about one.

Then comes the trap. "Your service needs 99.9 percent. It calls a payment provider with a 99.5 percent contract, on every request." If that call is synchronous and unguarded, your ceiling is the dependency's number and no amount of your own reliability recovers it. The answers that pass are a timeout with a bounded retry, a cached or degraded response path, moving the call off the request path, or renegotiating the SLO to match physics. "We would add more replicas" does not pass.

The container internals question, worked

On the DevOps side the equivalent depth check is containers. The framing that scores is that a container is not a small virtual machine. It is an ordinary Linux process with three things wrapped around it: namespaces limiting what it can see (pid, net, mnt, uts, ipc, user, cgroup), cgroups limiting what it can consume, and a layered filesystem, usually overlayfs, giving it its own root. Capabilities and seccomp then trim what it is allowed to ask the kernel for.

Interviewers push on the consequences, and these three come up repeatedly:

Why exit code 137

137 is 128 plus signal 9. The kernel killed the process, and inside a container that usually means the cgroup memory limit was reached. 143 is 128 plus signal 15, an ordinary SIGTERM, so it is a graceful shutdown rather than an incident. Knowing the arithmetic rather than the folklore reads well, and it leads naturally into the difference between a request and a limit.

Why a runtime sees the host's memory

Parts of /proc, including meminfo, are not namespaced, so a process reading them sees the machine rather than its own limit. Older JVMs and several other runtimes sized their heaps from that number and then got killed at a far smaller cgroup limit. Modern runtimes read the cgroup limit instead, which is why the real fix is often a runtime upgrade rather than a bigger memory request.

Why a CPU limit causes latency spikes at low utilisation

CPU limits are enforced as a quota inside a scheduling period, typically 100ms. A service that is idle on average but bursty can exhaust its slice early in a period and then wait for the next one, which appears as tail latency while the dashboard shows modest average CPU. The evidence is the throttling counters in the cgroup's CPU statistics, and the usual remedy is raising or removing the limit while keeping the request honest.

An SRE interviewer can ask exactly these questions, but the follow-up differs. DevOps asks how you would stop it happening across every team. SRE asks how you would have found it at three in the morning with only the dashboards that already exist. One worked answer per framing beats treating them as two topics, and the question banks are a reasonable place to sort prompts by the framing they belong to.

Where a copilot earns nothing in these loops

The live troubleshooting round is the worst possible fit for live assistance, and it is the round SRE loops weigh most heavily. You are typing into a shared terminal while the interviewer watches the commands scroll past, grading the order you check things in and whether you say what you expect to see before you press enter. Reading a suggestion breaks that narration, and pasting a command you cannot justify fails at the first follow-up. That round has to come from practice, and our walkthrough of the SRE Linux troubleshooting round covers the triage order worth rehearsing.

Windows only. OfferPilot AI runs on Windows 10 and 11. There is no macOS build, no Linux build, no mobile app and no browser extension. A large share of infrastructure engineers interview from a Mac or a Linux desktop, and for them none of this applies.
Capture exclusion covers screen sharing and screen recording, nothing else. The overlay is excluded from screen capture at the operating system level, so it does not appear in Zoom, Teams, Meet, OBS or screenshots, while staying visible on your own monitor. It does nothing about a webcam, a lockdown browser, eye tracking, a second-device camera or a person in the room.
Incident roleplay is graded on your questions, not your answers. The interviewer is waiting to hear you ask who else is affected, what changed in the last hour, and whether you can mitigate before you understand. A prompted answer arrives in the wrong shape entirely.
Follow the process rules you were sent. Some companies permit documentation and AI assistance openly, some do not. Ask when the instructions are ambiguous.

Where it does pay is narrower: the spoken breadth questions in either loop, where a prompt restores a definition you already knew, the postmortem and behavioural discussion, and the algorithms round some SRE tracks still run, which Code Copilot handles as a screenshot-to-solution path with a dry run and complexity attached.

Prepare for one loop, not the union of both

The two revision plans barely intersect. For a DevOps loop, design a pipeline out loud in ten minutes and defend one structural decision in your Terraform layout. For an SRE loop, do budget arithmetic without a calculator and narrate one real incident from page to postmortem. If the posting is still ambiguous after the decoder above, ask the recruiter which rounds are on the schedule and whether the coding exercise is algorithms or scripting. That answer redirects a week of preparation.

DevOps interview vs SRE interview: what each loop actually asks