CAP theorem
~11 minTwo data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Walk into DevOps and SRE interviews ready to ship software and keep it running. Covers Linux and networking, cloud and containers, IaC and CI/CD, observability and reliability practice, and security.
7251 of 7251 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 7251 new. 0 cut, outside your plan.
DevOps and SRE loops are run against a machine more than a whiteboard. After a recruiter screen, the first technical round is usually Linux and scripting in a shared terminal: find the process holding a port, explain why `df` reports a full disk while `du` cannot find the files (a deleted log a running process still has open), make a cron job stop failing silently. A troubleshooting round follows, often as a scenario told aloud: deploys succeed but a slice of requests times out, a pod cycles through `CrashLoopBackOff`, a DNS change went out an hour ago and half the traffic still reaches the old address. From middle level up there is an infrastructure design round, a delivery path for twenty services or a failover with a stated recovery time, and the loop ends with a behavioral conversation built on on-call stories. A coding round is lighter than in a software engineering loop but rarely missing, usually a parsing or aggregation problem in Python or Bash. The scoring follows the sequence of your checks, and whether you name the blast radius before you touch anything. Saying `kubectl describe` is a start; knowing that a failed readiness probe removes the pod from its Service while a failed liveness probe restarts the container, that a `TIME_WAIT` pile-up on a proxy is port exhaustion and not a backend fault, and that restarting a pod on a saturated node relocates the symptom, is the answer. Design questions are scored on the same reflex: a service level stated as a number with an error budget behind it, a rollout that can stop halfway, a change that reverts without a second change, and a plan for the three places state lives, the Terraform state file, the database and the cluster itself.
A terminal is the first thing an interviewer hands you, and the plan begins there: the [operating system and its service manager](/topics/os-shell), the [shell](/topics/lang-bash) that drives it, and the [repository](/topics/dev-vcs) the work is committed to. Networking then runs up the stack in three stretches, from packets to connections to sessions: [CIDR arithmetic](/topics/proto-cidr), forwarding and address translation; TCP taken apart from handshake to teardown, with UDP and [DNS](/topics/proto-dns); then HTTP inside [TLS](/topics/proto-tls) and PKI, SSH and file transfer. It is placed this early because a VPC, a Kubernetes Service and a reverse proxy are the same CIDR, NAT and TCP questions under new names, and the plan settles them once. The platform follows. [Cloud concepts](/topics/cloud-providers-concepts) and serverless are two ways of renting compute, kept vendor-neutral so the trade-offs survive a change of provider. The container modules go from the generic model to Docker, which builds and runs, to [Kubernetes](/topics/cloud-kubernetes), which schedules, to Helm, which packages what Kubernetes runs. Only once something is running does the plan ask how change reaches it: [infrastructure as code](/topics/cloud-iac-concepts), worked through in [Terraform](/topics/cloud-terraform), describes the target, [pipelines](/topics/cloud-cicd-concepts) and GitOps move the change, push against pull, and artifact management holds the versioned, immutable thing that moves. [Proxies and service meshes](/topics/cloud-networking) come after the orchestrator because a mesh assumes a cluster. Once change can flow, the plan asks how you would notice it going wrong. Observability starts with the signals themselves, then [Prometheus](/topics/cloud-prometheus) before Grafana, since a panel over Prometheus is a PromQL query with a frame around it, and [OpenTelemetry](/topics/cloud-opentelemetry) last as the vendor-neutral way to produce all three signals. [SRE practice](/topics/cloud-sre-practices) sits directly after, because a service level objective is a query over metrics you have just learned to collect, and an alert is a decision about which of them wakes someone. [Replication, backup and failover](/topics/db-relational-replication-ha) and schema migration follow as the state a stateless pipeline cannot roll back for you. Security waits until the things it protects exist: [secret management](/topics/sec-secrets-mgmt-concepts) assumes you know where a credential travels, and supply chain security and [policy as code](/topics/sec-policy-as-code) gate the pipelines, registries and admission paths the earlier stretches built. The plan closes with the rounds most engineering loops share: working with an AI assistant, the [algorithms](/topics/found-dsa) of the coding round, [distributed systems and system design](/topics/found-system-design) with the resilience patterns a design round expects you to name and cost, and the [behavioral conversation](/topics/found-behavioral).
Coming from a help desk or a sysadmin role, give the opening and networking stretches the most time; an interviewer who hears you reason from a packet to a page will forgive thin Helm. Coming from backend development, you already have the repository, the coding round and most of system design, so begin at the cloud and container modules and treat SRE practice and observability as the new material, because the questions there assume you have carried a pager. A senior SRE preparing for a staff loop gets more from the design and reliability stretches, the postmortem and capacity sections above all, than from re-reading commands. Two weeks out, the plan is longer than the time, so cut it before you read it: raise importance to must know, narrow level to the band the posting names, and leave study order on by frequency, which puts the terminal and troubleshooting questions most loops repeat at the front. A whole season allows the opposite: switch to by topics, begin at the operating system and read downward, because each stretch is asked in the vocabulary the one above it supplied. The cloud module explains a region, a tenancy boundary and a managed service without taking a provider's side; no module here teaches one vendor's console, IAM policy language or VPC constructs. When the posting names the provider, the [AWS roadmap](/roadmaps/aws) is that provider's half. The plan also takes IP only as far as forwarding: the routing protocols that carry a prefix between networks, and the switching beneath IP, belong to the [Network Engineer roadmap](/roadmaps/network-engineer).
Two data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
DevOps and SRE loops are run against a machine more than a whiteboard. After a recruiter screen, the first technical round is usually Linux and scripting in a shared terminal: find the process holding a port, explain why df reports a full disk while du cannot find the files (a deleted log a running process still has open), make a cron job stop failing silently. A troubleshooting round follows, often as a scenario told aloud: deploys succeed but a slice of requests times out, a pod cycles through CrashLoopBackOff, a DNS change went out an hour ago and half the traffic still reaches the old address. From middle level up there is an infrastructure design round, a delivery path for twenty services or a failover with a stated recovery time, and the loop ends with a behavioral conversation built on on-call stories. A coding round is lighter than in a software engineering loop but rarely missing, usually a parsing or aggregation problem in Python or Bash.
The scoring follows the sequence of your checks, and whether you name the blast radius before you touch anything. Saying kubectl describe is a start; knowing that a failed readiness probe removes the pod from its Service while a failed liveness probe restarts the container, that a TIME_WAIT pile-up on a proxy is port exhaustion and not a backend fault, and that restarting a pod on a saturated node relocates the symptom, is the answer. Design questions are scored on the same reflex: a service level stated as a number with an error budget behind it, a rollout that can stop halfway, a change that reverts without a second change, and a plan for the three places state lives, the Terraform state file, the database and the cluster itself.
A terminal is the first thing an interviewer hands you, and the plan begins there: the operating system and its service manager, the shell that drives it, and the repository the work is committed to. Networking then runs up the stack in three stretches, from packets to connections to sessions: CIDR arithmetic, forwarding and address translation; TCP taken apart from handshake to teardown, with UDP and DNS; then HTTP inside TLS and PKI, SSH and file transfer. It is placed this early because a VPC, a Kubernetes Service and a reverse proxy are the same CIDR, NAT and TCP questions under new names, and the plan settles them once.
The platform follows. Cloud concepts and serverless are two ways of renting compute, kept vendor-neutral so the trade-offs survive a change of provider. The container modules go from the generic model to Docker, which builds and runs, to Kubernetes, which schedules, to Helm, which packages what Kubernetes runs. Only once something is running does the plan ask how change reaches it: infrastructure as code, worked through in Terraform, describes the target, pipelines and GitOps move the change, push against pull, and artifact management holds the versioned, immutable thing that moves. Proxies and service meshes come after the orchestrator because a mesh assumes a cluster.
Once change can flow, the plan asks how you would notice it going wrong. Observability starts with the signals themselves, then Prometheus before Grafana, since a panel over Prometheus is a PromQL query with a frame around it, and OpenTelemetry last as the vendor-neutral way to produce all three signals. SRE practice sits directly after, because a service level objective is a query over metrics you have just learned to collect, and an alert is a decision about which of them wakes someone. Replication, backup and failover and schema migration follow as the state a stateless pipeline cannot roll back for you.
Security waits until the things it protects exist: secret management assumes you know where a credential travels, and supply chain security and policy as code gate the pipelines, registries and admission paths the earlier stretches built. The plan closes with the rounds most engineering loops share: working with an AI assistant, the algorithms of the coding round, distributed systems and system design with the resilience patterns a design round expects you to name and cost, and the behavioral conversation.
Coming from a help desk or a sysadmin role, give the opening and networking stretches the most time; an interviewer who hears you reason from a packet to a page will forgive thin Helm. Coming from backend development, you already have the repository, the coding round and most of system design, so begin at the cloud and container modules and treat SRE practice and observability as the new material, because the questions there assume you have carried a pager. A senior SRE preparing for a staff loop gets more from the design and reliability stretches, the postmortem and capacity sections above all, than from re-reading commands.
Two weeks out, the plan is longer than the time, so cut it before you read it: raise importance to must know, narrow level to the band the posting names, and leave study order on by frequency, which puts the terminal and troubleshooting questions most loops repeat at the front. A whole season allows the opposite: switch to by topics, begin at the operating system and read downward, because each stretch is asked in the vocabulary the one above it supplied.
The cloud module explains a region, a tenancy boundary and a managed service without taking a provider's side; no module here teaches one vendor's console, IAM policy language or VPC constructs. When the posting names the provider, the AWS roadmap is that provider's half. The plan also takes IP only as far as forwarding: the routing protocols that carry a prefix between networks, and the switching beneath IP, belong to the Network Engineer roadmap.