Infrastructure Operations Fundamentals
Infrastructure operations is the practice of keeping a production service observable, dependable, and recoverable as systems, traffic, software, and people change. It connects service-level objectives, monitoring, incident response, and blameless postmortems into one feedback loop.
itInfrastructure and operations | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Infrastructure Operations Fundamentals
Infrastructure operations is the practice of keeping a production service usable while everything about it changes — the systems, the traffic, the software, and the people. It is not a tool category, and it is not a job title. It is a loop.
Before this loop had a name, a service that broke at three in the morning broke the person who built it, who then fixed it however they could and went back to sleep. The loop exists so that failure produces a system that fails less next time, instead of a tired engineer.
Three ideas hold the whole thing up. Define what good service looks like with a service level objective — a target for a user-visible measurement, negotiated with the business, carrying an error budget that says how much unreliability is allowed. Observe the service with monitoring, and alert only when a person needs to act, not every time a number moves. Then respond as a team when impact needs coordinated work, and learn from it with a blameless postmortem.
The one thing that will surprise you: an alert is not a diagnosis. A dashboard full of green is not proof your users are succeeding, and a dashboard full of red is not a root cause. Monitoring gathers evidence; alerting asks for action. Most measurements should produce neither — they are context, not pages, and paging on every change is how a team learns to ignore the signal that matters.
The thing that catches every team the first time: blame feels productive and is not. A blameless postmortem assumes everyone did the right thing with the information they had, and it investigates the systems that let the wrong information exist. Naming a person feels like progress and suppresses the next report; the loop only works when people bring failures to light without fear.
Toil — manual, repetitive, automatable work that scales linearly with growth — is the thing the loop is supposed to convert into engineering. Automate the repeatable part, but keep an owner, an observable result, a bounded target, and a recovery path, because automating a broken process just produces broken processes faster.
Read the Intro for the full loop and the vocabulary that holds it together. The Cheatsheet is the reference you will reach for when you forget which monitoring output is which. The Timeline shows how a practice that once meant "the person who built it fixes it" became a discipline with SLOs, error budgets, and blameless postmortems — and why the tools keep changing while the loop does not.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://sre.google/sre-book/table-of-contents/
Supports
- SRE principles for service level objectives
- error budgets
- toil
- monitoring
- alerting
- incident management
- and postmortems
- https://sre.google/sre-book/service-level-objectives/
Supports
- SLI and SLO definition
- error budget concept
- negotiating targets with the business
- https://sre.google/sre-book/monitoring-distributed-systems/
Supports
- Four monitoring outputs — alerts
- tickets
- logging
- debugging — and the difference between monitoring and alerting
- https://sre.google/sre-book/postmortem-culture/
Supports
- Blameless postmortem practice
- postmortem triggers
- review and sharing
- cultivating a postmortem culture
- https://sre.google/sre-book/eliminating-toil/
Supports
- Definition of toil as manual
- repetitive
- automatable
- no enduring value
- scaling linearly
- https://sre.google/sre-book/automation-at-google/
Supports
- Automation with owner
- observable result
- bounded target
- and recovery
- https://sre.google/resources/practices-and-processes/incident-management-guide/
Supports
- Incident roles
- tasks
- communication
- documentation
- and improvement without blame
- https://sre.google/workbook/table-of-contents/
Supports
- Practical SLO implementation
- monitoring
- alerting
- on-call
- incident response
- postmortems
- https://prometheus.io/docs/introduction/overview/
Supports
- Prometheus as a time-series monitoring and alerting toolkit descended from Borgmon
- https://en.wikipedia.org/wiki/Prometheus_(software)
Supports
- Prometheus origin at SoundCloud 2012
- CNCF acceptance May 2016
- graduation August 2018
- 1.0 in July 2016
- https://opentelemetry.io/
Supports
- Vendor-neutral instrumentation standard for metrics
- logs
- and traces; merger of OpenTracing and OpenCensus
- https://en.wikipedia.org/wiki/Kubernetes
Supports
- Kubernetes 1.0 release in 2014 as a declarative reconciliation substrate for operations
- https://en.wikipedia.org/wiki/PagerDuty
Supports
- PagerDuty founding in 2009 as productized on-call alert routing
- https://en.wikipedia.org/wiki/Datadog
Supports
- Datadog founding in 2010 as hosted cloud-scale metrics and dashboards
- https://www.nagios.org/
Supports
- Nagios as a long-standing check-based host and service monitor
- https://www.zabbix.com/
Supports
- Zabbix as a mature agent-and-poll network and application monitor
- https://grafana.com/
Supports
- Grafana as the dashboard and visualization pairing for monitoring data
- https://www.datadoghq.com/
Supports
- Datadog managed observability platform bundling metrics
- logs
- traces
- dashboards
- alerting
- https://newrelic.com/
Supports
- New Relic application observability platform with SLO tracking
- https://www.dynatrace.com/
Supports
- Dynatrace AI-assisted observability and anomaly detection
- https://www.splunk.com/
Supports
- Splunk log and event analytics platform
- https://www.elastic.co/
Supports
- Elasticsearch and Kibana as open-source log aggregation and search
- https://www.ansible.com/
Supports
- Ansible configuration and automation tooling
- https://www.terraform.io/
Supports
- Terraform infrastructure-as-code provisioning with state
