Infrastructure and operations
How the field of a Site Reliability Engineer got here: the sourced milestones from every published course of this career, on one axis.
1950 to 2026
207 milestones across 23 courses
The axis stretches toward recent years, where most milestones fall. Bars count milestones per year; dots are single milestones.
7 milestones
1950
Taiichi Ohno introduced the Five Whys technique at Toyota as a way to push past a symptom to the underlying cause of a manufacturing error by asking "why" repeatedly. It became the "why" half of the what/where/why narrowing technique this course teaches.
1960
The hypothetico-deductive model — form hypotheses from observations, test them, discard what fails — was formalized as the method of science. Google's SRE book later framed systems troubleshooting as exactly this method applied to a running system.
1981
NIST's history records FIPS 87 as an early guideline for automatic data processing contingency planning. It established continuity planning as a defined concern for computerized operations.
1981
NIST published Guidelines for ADP Contingency Planning. It established federal guidance for planning recovery of automatic data processing systems.
1982
The Executive Guide to ADP Contingency Planning made contingency planning guidance available for mainframe-era information processing. It extended the early federal planning corpus.
1982 Jun
Susan L. Graham, Peter B. Kessler and Marshall K. McKusick present gprof at the SIGPLAN '82 Symposium on Compiler Construction. It extends the existing UNIX profiler by gathering arcs of a program's call graph, so the running time of a called routine is attributed to the routines that called it. The GNU implementation combines an `mcount` call compiled into every function entry with program-counter sampling around 100 times per second, and reports both a flat profile and a call graph — the self-versus-total distinction every profiler has carried since.
1985
The Guide on Selecting ADP Backup Process Alternatives documented backup-process alternatives for information systems. It made recovery strategy selection an explicit planning activity.
4 milestones
1993 Jan
The paper described a register-based packet filter that discarded unwanted traffic before copying it to user space. It established filtering near the event as a model later BPF systems expanded.
1996
Nagios history records a monitoring application that checked servers and sent numeric pages. It established a detect-and-page path that later on-call systems automated and routed.
1999
Nagios popularized host and service check-based monitoring with active probes and alerting on check failures. It defined a generation of operations practice centered on "is it up" checks rather than user-visible behavior.
1999
The project was released publicly as NetSaint. Open distribution made monitoring checks and notification patterns available to operations teams outside a single managed-service environment.
14 milestones
2001
Zabbix introduced a network and application monitoring system with agents, polling, and a database-backed history. It joined Nagios as a long-running open-source monitoring choice for operations teams.
2001 Aug
The informational RFC described the widely deployed BSD syslog message format and relaying behavior. It gave operators a common reference for a protocol that had grown through implementation practice.
2002
A trademark-driven rename established Nagios as the project identity. The monitoring and notification architecture continued under that name.
2002
NIST published its Contingency Planning Guide for Information Technology Systems. The guide brought business impact analysis, contingency strategies, plan development, testing, and maintenance into one IT planning process.
2002 Jun
NIST published the Contingency Planning Guide for Information Technology Systems. The guide covered a contingency-planning process and technical considerations for IT systems.
2005
NIST published the first SP 800-53 control catalog. It placed contingency planning among the recommended security outcomes that organizations could tailor to system risk.
2006
NIST SP 800-84 provided guidance on testing, training, and exercising IT plans and capabilities. It distinguished preparation activities from evidence that a plan can operate.
2006 Mar
The transport specification defined how syslog messages can use TLS. It made transport protection an explicit logging architecture choice rather than an assumed property of a message format.
2006 Sep 19
Python 2.5 adds cProfile, "a C implementation of the existing profile module that has much lower overhead", contributed by Armin Rigo. Deterministic profiling — monitoring every function call, return and exception with precise interval timing — becomes available by default in a mainstream language, along with the documented limits that come with it, including the distortion of Python-versus-C timing comparisons.
2009
PagerDuty productized on-call alert routing, separating paging from the monitoring system that produced the signal. It made the alerting layer an operational concern in its own right.
2009 Mar
RFC 5424 replaced RFC 3164 with a standardized message format and structured data element. It formalized record structure and separated protocol concerns from transport selection.
2009 Mar
The UDP transport mapping documented message-size and delivery limitations for datagram transport. It kept loss and truncation in the operational design discussion.
2009 Aug
PagerDuty says its initial beta launched in August 2009. Hosted paging made schedules, multi-channel notification, and escalation a managed response layer.
2009 Sep 9
The kernel gains a performance counter subsystem abstracting the hardware registers that count instructions executed, cache misses and mispredicted branches, together with the `perf` userspace tool providing `perf top`, `perf record`, `perf report` and `perf annotate`. Sampling profiling stops being a per-application feature and becomes a kernel service any process on the machine can be measured with.
116 milestones
2010
Google published Dapper's design for low-overhead, application-level tracing across a large distributed system. The paper made sampling and shared instrumentation libraries central practical concerns.
2010
Datadog began offering cloud-scale metrics aggregation and dashboards as a service, moving monitoring infrastructure off the operations floor and toward a hosted product.
2010
Google published Dapper, its distributed tracing system, making the request path across components observable. Tracing became the third signal — alongside metrics and logs — that lets a troubleshooter apply bisection to a multi-hop call.
2010
Gang Ren, Eric Tune, Tipp Moseley, Yixin Shi, Silvius Rus and Robert Hundt describe a continuous profiling infrastructure running across Google's data centers in IEEE Micro, reporting stable, accurate profiles at negligible overhead. It establishes that always-on fleet-wide profiling is affordable, and demonstrates analyses that only exist once profiles are collected everywhere, such as measuring application affinity to particular hardware platforms.
2010
Google described a production distributed tracing system for large-scale services. The paper made trace-based latency analysis a concrete operational pattern beyond single-process profiling.
2010
The paper described a production tracing infrastructure for large, distributed systems, including ubiquitous instrumentation and sampling. It gave practitioners a concrete model for following work across services rather than inspecting hosts in isolation.
2010
Netflix created Chaos Monkey to terminate production instances and test tolerance of instance failure.
2010
Revision 1 updated the federal contingency planning guide and described its relationship to related security and emergency management plans. It retained a system-focused process for determining requirements and priorities.
2010 Feb
Elasticsearch began as a distributed search engine. Searchable storage became a common backend pattern for log analysis as it was combined with collectors and visualization tools.
2010 Apr
Google describes its internal distributed tracing infrastructure, establishing the conceptual foundation for trace-based observability in large-scale systems.
2010 Jun
AWS described backup and disaster-recovery use cases for cloud storage and service providers. Cloud storage changed how teams could obtain off-site recovery capacity.
2010 Oct
The draft defined browser timing for document navigations. It gave page-load monitoring a browser-provided time model instead of ad hoc JavaScript timers.
2010 Nov
Revision 1 updated the contingency-planning guide with practical guidance on plan development, requirements, priorities, resilience, and the system development life cycle.
2011 Jun
Fluentd introduced an open-source collector for routing events from varied sources to varied destinations. Collection and transformation became a distinct pipeline stage rather than an application-only concern.
2011 Jun 24
The Go team documents profiling as part of the language toolchain rather than an external tool, walking through a full optimization session with `go tool pprof`. The runtime samples the executing goroutine's stack about 100 times per second and samples the heap roughly once per half megabyte allocated, and the profile.proto format it emits later becomes the interchange format much of the profiling market stores.
2011 Jul
Netflix expanded from instance termination to a suite inducing failures and detecting abnormal conditions.
2011 Dec
Brendan Gregg releases the flame graph after working a MySQL performance problem, fixing stack depth on the y-axis and an alphabetically sorted stack population on the x-axis so that identical adjacent frames merge into single wide blocks. Profile output stops being a table to read and becomes a picture to scan, and the format spreads to off-CPU, memory, hot/cold and differential variants.
2012
Ansible's creator began the project in 2012. The initial focus was automation over standard remote connections rather than a permanent managed-node agent.
2012
ISO 22301:2012 became the earlier published edition identified in ISO's lifecycle for the business continuity management-system standard. It framed continuity as an organization-wide management system.
2012
Prometheus began as an open-source project in 2012. Its timestamped, label-based series model gave practitioners a common way to describe metric identity and aggregation.
2012
Prometheus began as an open-source monitoring project at SoundCloud. Its time-series model based on timestamps and labels became a practical reference point for metrics collection and cardinality.
2012
Zipkin made distributed tracing available as a reusable open-source system. Practitioners could collect and inspect request timing across service boundaries without building a tracing backend from scratch.
2012 May 22
Etsy publicly described blameless postmortems as a way for engineers to provide actions, observations, expectations, assumptions, and timelines without fear of punishment. The publication made contextual accounts a visible engineering practice.
2012 Dec
The first Navigation Timing Recommendation standardized document-navigation measurements. RUM implementations could use a shared browser interface for page-load evidence.
2013
Google's internal SRE practice began to influence the wider industry through talks and hiring, formalizing SLIs, SLOs, error budgets, toil, and blameless postmortems as named practices rather than ad hoc habits.
2013
Prometheus was introduced for production monitoring at SoundCloud in 2013. Production use tested its model against real service behavior before broader adoption.
2013 Feb
The project announced Ansible 1.0 after a sequence of earlier releases. Releases became a distribution path alongside using the upstream Git repository.
2013 May
Elasticsearch, Logstash, and Kibana became a recognizable combination for ingesting, searching, and visualizing log data. The stack made the separation of pipeline roles visible in common deployment practice.
2013 Sep
The project announced Ansible 1.3 with AWX 1.3. This established an early controller-oriented companion to command-line playbook execution.
2013 Dec
Performance Timeline standardized retrieval of performance entries. This established the entry model later used by observers and timing APIs in browser instrumentation.
2014
Netflix formalized chaos engineering as the discipline of experimenting on a production system to build confidence in its resilience, with Chaos Monkey. It reframed troubleshooting's preventive counterpart: instead of diagnosing failures, deliberately cause them.
2014
DORA reports that it operationalized and validated Westrum's organizational-culture model in 2014. The model connected information flow, cooperation, trust, bridging, and inquiry to software-delivery research.
2014
Etsy's progress report recorded more than 100 postmortems in 2014, each using collective timeline reconstruction and remediation planning. It documented the practice as an organizational program rather than an isolated incident ritual.
2014
Google SRE records a 2014 internal presentation about high-impact incidents and postmortem practice. It shows postmortem discussion becoming part of a broader engineering learning culture.
2014
Kubernetes 1.0 and Terraform shipped within a year, giving operations a declarative reconciliation and infrastructure-as-code substrate that turned change into a repeatable, observable action rather than a manual procedure.
2014 Jan
Torkel Ödegaard open-sources Grafana as a dashboard for Graphite time-series data, beginning what becomes the standard visualization layer for cloud-native metrics.
2014 Jun
Kubernetes was publicly announced after its first commit in June 2014. Cluster operation became a distinct concern as the project moved beyond container scheduling experiments.
2014 Jun
Kubernetes began as an open-source project, establishing a shared control plane for running container workloads across machines.
2014 Jun 6
Google engineers push the project's first commit, distilling lessons from a decade of running Borg internally into an open source container orchestrator.
2014 Dec
Linux 3.18 introduced the bpf system call for loading BPF-like programs, maps, and helper calls. This made programmable in-kernel collection a Linux subsystem rather than only a packet-filter mechanism.
2014 Dec
Resource Timing standardized detailed measurement for fetched resources. It gave field investigations a browser source for request-phase evidence, subject to origin controls.
2015
OpenTracing focused on common APIs for instrumenting distributed systems. This shifted instrumentation toward a portable interface rather than a backend-specific library.
2015
The principles defined steady state, hypotheses, real-world events, production behavior, and automation as a common experiment model.
2015
Uber created Jaeger as an internal distributed tracing platform. It provided an open-source implementation focused on monitoring and troubleshooting cloud-native architectures.
2015 Jan
After production use at SoundCloud and early external adoption, the project was announced to the wider public. This expanded the open metrics ecosystem around the label-based data model.
2015 Jul
BCC packaged tracing tools and language front ends around BPF programs. It made focused investigations more accessible before teams built persistent collectors.
2015 Jul
Kubernetes 1.0 reached release and was donated to the newly formed CNCF. The project acquired a production-facing governance and release home.
2015 Jul
Version 1.0 established the first stable release and accompanied Kubernetes' donation to the CNCF.
2015 Jul
Kubernetes reached its v1.0 release, establishing the platform that later networking APIs and implementations build upon.
2015 Jul 21
Google declares Kubernetes production-ready at 1.0 and hands the project to the newly formed Cloud Native Computing Foundation, separating it from any single vendor's control.
2015 Oct
Red Hat announced an agreement to acquire Ansible and described Ansible and Ansible Tower as part of its management portfolio. Supported enterprise automation became a parallel path to the upstream project.
2016
The 2.0 porting guide documented behavioral changes for playbooks, plugins, and the Python API. Existing automation needed compatibility review rather than assuming a version upgrade was transparent.
2016
The Google SRE book made its postmortem-culture chapter publicly available with criteria, blameless language, review, and sharing practices. It gave teams a documented SRE reference for treating incident reviews as learning work.
2016
Uber released Jaeger as an open-source distributed tracing platform and later donated it to CNCF. This made the backend available outside its original environment.
2016
Prometheus joined the Cloud Native Computing Foundation as its second hosted project. Metrics collection and alerting became a prominent shared component of cloud-native operations.
2016 Mar
User Timing standardized application-defined marks and measures. Teams could add domain-specific spans when browser timing alone did not identify a meaningful application operation.
2016 Mar 10
The foundation's Technical Oversight Committee takes on Kubernetes as CNCF's inaugural project, giving the desired-state model this course teaches a neutral governance home.
2016 Apr
The first edition documented an SRE operating model, including on-call work, for a wider engineering audience. It connected response duty with service ownership and engineering work that reduces operational load.
2016 Apr
Google released the Site Reliability Engineering book under Creative Commons, including the "Effective Troubleshooting" chapter that framed troubleshooting as the hypothetico-deductive method and named the common pitfalls. It is the source this course follows.
2016 Apr
Google released the SRE book under Creative Commons, making its practices public. The book codified SLOs, error budgets, toil, monitoring outputs, incident management, and blameless postmortem culture for the wider industry.
2016 May
CNCF accepted Prometheus as a hosted project. Its metric model became a widely used companion to traces for rates, errors, and latency distributions.
2016 May
Prometheus, built at SoundCloud and modeled on Google's Borgmon, became the CNCF's second hosted project. It carried the time-series, label-based alerting model into open source.
2016 Jul
Prometheus 1.0 established a stable multi-dimensional metrics model with PromQL and pull-based collection, the implementation of the alerting model the SRE book describes.
2016 Aug
OpenTracing joined the CNCF in August 2016. Its API effort focused attention on portable instrumentation rather than backend-specific tracing code.
2016 Sep
Kubernetes 1.4 introduced relative Pod placement rules and PodDisruptionBudget support for limiting disruption from cluster management operations.
2016 Sep
Kubernetes 1.4 introduced kubeadm for bootstrapping a control plane and joining nodes. It made self-managed cluster lifecycle steps more repeatable.
2016 Oct
CNCF accepted OpenTracing as a hosted project. The project aimed to make tracing and context propagation consistent across loosely coupled microservices.
2016 Oct
XDP added a programmable high-performance network data path. It broadened BPF use beyond tracing into early packet processing and network observability.
2016 Oct
CNCF accepts OpenTracing as its third hosted project, establishing a vendor-neutral API standard for distributed tracing.
2016 Nov 17
Etsy published a facilitation guide that moved from the philosophy of blamelessness to running debriefings as a learned skill. It emphasized resisting premature causal stories and gathering multiple perspectives.
2016 Dec
Linux 4.9 added a more efficient BPF profiler. This strengthened sampled profiling as a BPF observability use case instead of tracing every function call.
2017
Litmus started with chaos jobs for Kubernetes, bringing fault experiments into the workload orchestration environment.
2017 Feb
A paper described the principles and their use in reliability experiments beyond Netflix.
2017 Mar
Kubernetes 1.6 moved node affinity, taints and tolerations, Pod affinity, and multiple schedulers into beta.
2017 Mar
SIG Cluster Lifecycle described shipping kubeadm with the Kubernetes 1.6 distribution. Cluster bootstrap and lifecycle tooling became part of the project’s regular release surface.
2017 Jun
Kubernetes 1.7 promoted NetworkPolicy to stable, making label-based Pod communication rules a stable API while leaving enforcement to network plugins.
2017 Jun 29
CRDs replace the earlier ThirdPartyResource mechanism, letting teams extend the kube-apiserver with their own object kinds instead of working only with what ships in core.
2017 Sep
CNCF accepted Jaeger at the Incubating maturity level. The project then developed as part of the CNCF observability ecosystem.
2017 Sep
Jaeger joined CNCF in September 2017. The project made an open tracing backend available within the cloud-native ecosystem.
2017 Oct
Kubernetes 1.8 added egress policy capabilities, allowing workloads to restrict connections they initiate as well as inbound connections.
2017 Oct 17
Docker Enterprise Edition folds unmodified upstream Kubernetes in alongside Swarm, conceding that the object model this course introduces had become the default rather than one option among several.
2017 Nov 29
AWS announces a managed control plane for Kubernetes at re:Invent, the first sign that the major clouds would sell Kubernetes's control plane as a service rather than leave operators to run etcd and kube-apiserver themselves.
2017 Dec
The 1.0 backend release marked a deployable open-source baseline with broader storage and interoperability work.
2018
DORA's 2018 report described generative culture as cooperation, trust, voice, and learning, and associated it with stronger software-delivery and organizational outcomes. It made culture a measured capability in the DevOps research program.
2018
The workbook added a case study, templates, action-item guidance, incentives, and warning signs for a postmortem culture. It translated the earlier SRE philosophy into operating practices a team can adopt.
2018
OpenCensus provided common libraries for collecting traces and metrics. It represented a parallel standardization path that later converged with OpenTracing.
2018
Google's companion workbook moved from the SRE model to practical implementation examples. On-call became part of an explicit reliability practice rather than an isolated alert-receiving duty.
2018 Jan
Google releases OpenCensus, a vendor-neutral library for metrics collection and distributed tracing derived from its internal Census library.
2018 Mar
Kubernetes 1.10 made the default StorageClass annotation beta. Operators increasingly had to treat storage behavior and defaulting as cluster-wide lifecycle concerns.
2018 Mar 6
CNCF certifies Kubernetes as having thriving adoption and a documented governance process — the first project to clear the foundation's graduation bar.
2018 May
The Long Tasks API exposed main-thread tasks of at least 50 milliseconds. RUM collectors gained a standard signal for browser work that can delay queued input.
2018 Jun
Splunk added VictorOps collaborative incident-management capabilities to its portfolio. The acquisition linked on-call response more closely with observability and incident collaboration platforms.
2018 Jun 5
AWS's managed control plane leaves preview, joining Google's and soon Azure's equivalents and cementing "rent the control plane, run your own nodes" as the default way most teams meet Kubernetes.
2018 Aug
Linux 4.18 introduced BPF Type Format, a compact type metadata format. BTF became a building block for typed tracing and later portability work.
2018 Aug
The CNCF announced Prometheus had graduated from incubation, confirming the time-series alerting model as production-grade and widely adopted across cloud-native operations.
2018 Aug
Prometheus becomes CNCF's second graduated project after Kubernetes, validating its maturity for production cloud-native monitoring.
2018 Sep 25
JEP 328 moves Flight Recorder, previously a commercial feature of the Oracle JDK, into the open repository and delivers it in JDK 11, which reaches General Availability on 25 September 2018. The stated goal is at most 1% overhead out of the box on SPECjbb2015 and no measurable overhead when disabled. A production-grade recorder of thread samples, lock profiles and allocation ships with the runtime rather than being purchased separately.
2018 Oct
Atlassian acquired Opsgenie, whose service included incident alerting and on-call schedule management. The move connected paging with service management and engineering work-tracking ecosystems.
2018 Nov
Grafana Labs open-sourced Loki as "like Prometheus, but for logs", proposing label-only indexing and object-storage chunks as an answer to the cost of full-text log indexing.
2018 Nov
The W3C Distributed Tracing Working Group published its first Trace Context draft. It defined portable HTTP headers for carrying trace identity across tool boundaries.
2018 Dec 3
Kubernetes 1.13 makes kubeadm stable, giving operators a first-party, certified path to bootstrap the control plane and node components this course's architecture section describes, instead of assembling them by hand.
2019
The merger of OpenTracing and OpenCensus into OpenTelemetry created a single vendor-neutral standard for emitting metrics, logs, and traces, unifying the evidence layer the monitoring and alerting loop depends on.
2019
OpenTracing and OpenCensus merged to form OpenTelemetry. The new project created a shared home for instrumentation across telemetry signals, including metrics.
2019 Mar
Kubernetes 1.14 made priority and preemption generally available, allowing higher-priority Pods to displace lower-priority work when capacity is scarce.
2019 May
The project positioned OpenTelemetry as the instrumentation layer and Jaeger as a tracing backend. That division became the basis for later client and protocol changes.
2019 May
OpenTracing and OpenCensus merge to form OpenTelemetry, a CNCF project unifying distributed tracing, metrics, and logging under one framework.
2019 May
The merged project established a vendor-neutral observability effort. It created a shared context for logs, metrics, and traces rather than treating each signal as an isolated tool.
2019 May
OpenTelemetry formed from the OpenTracing and OpenCensus projects. The merger combined tracing and telemetry instrumentation work into one vendor-neutral project.
2019 May
The two projects merged to form OpenTelemetry. The merge aimed to give instrumentation a common vendor-neutral home instead of asking libraries to choose between competing tracing APIs.
2019 Jun
Kubernetes 1.15 introduced the Scheduling Framework as an alpha extension surface for scheduler plugins.
2019 Jun
The first tagged release of the log aggregation system, with the Promtail agent, the push API, and LogCLI; Grafana integration provided the query interface.
2019 Jul
The project announced collections as the future distribution format for modules, plugins, roles, and playbooks, and added collection support in Ansible 2.9. Namespaces began to matter directly in playbook references.
2019 Sep
Kubernetes 1.16 removed several deprecated API versions. Upgrade preparation became inseparable from finding and migrating old manifests before a control-plane change.
2019 Oct
ISO published edition 2 of ISO 22301 in October 2019, replacing the 2012 edition. The standard specifies requirements for a business continuity management system.
2019 Oct
Jaeger becomes CNCF's seventh graduated project, establishing a production-grade distributed tracing backend alongside the emerging OpenTelemetry standard.
2019 Nov
After a year and roughly 1.5 TB / 10 billion log lines a day ingested internally at Grafana Labs, the team promoted Loki out of beta with an API-stability commitment centered on the operating experience.
66 milestones
2020 Feb
The CO-RE design combined target-kernel BTF, compiler relocations, and libbpf loading. It reduced dependence on compiling a BPF program separately for every kernel layout.
2020 Feb
W3C standardized HTTP headers and value formats for propagating trace context between services. This made trace identity portable across components and tracing implementations.
2020 May
Chrome grouped loading, interactivity, and visual stability as Core Web Vitals. Field monitoring could frame browser timings around user-facing outcomes rather than technical durations alone.
2020 May
Jaeger announced a Collector-based direction for collection functions. The change targeted a standardized telemetry pipeline and access to Collector processing features.
2020 May
Kubernetes 1.18 added topology spread constraints, allowing a workload to express a bounded imbalance across topology domains.
2020 Jun
Litmus became a CNCF Sandbox project and a community-governed framework for Kubernetes chaos workflows.
2020 Jul
Chaos Mesh entered the CNCF Sandbox with Kubernetes, network, I/O, and kernel fault types.
2020 Aug
Kubernetes 1.19 graduated Ingress to v1, stabilizing the core API for HTTP and HTTPS access to Services.
2020 Aug
Linux 5.8 separated selected BPF and performance-monitoring permissions from broad CAP_SYS_ADMIN. Observability agents could request more specific privileges for supported tracing programs.
2020 Aug
Starting with Kubernetes 1.19, the project extended patch support from about nine months to one year. Operators gained a longer but still finite upgrade planning window.
2020 Sep
The 2.10 schedule set its general-availability date for September 22. The release package was assembled from collection versions with compatibility rules instead of treating all content as one repository.
2020 Sep
In Kubernetes 1.19, kube-proxy began reading EndpointSlices by default, replacing large single Endpoints objects with smaller backend sets.
2020 Sep
Revision 5 updated the federal security and privacy control catalog. The contingency-planning family remained part of the risk-management control structure.
2020 Oct
The single-store design (index and chunks in one object store) reached production readiness, and LogQL gained query-time parsers, label filtering, and log-derived metrics, closing the gap with traditional log systems' query power.
2020 Dec 8
The kubelet's built-in Docker Engine support is marked for removal in favor of CRI-compliant runtimes, a reminder that the container runtime is a pluggable node component, not part of Kubernetes itself.
2021
The release-and-maintenance reference records Ansible 3 as the community package paired with ansible-core 2.10. Practitioners now need to distinguish the package release from the underlying runtime version.
2021 Feb
The AWS Well-Architected whitepaper formalized cloud disaster-recovery guidance. It organized recovery design around workload disruption, recovery options, detection, and testing.
2021 Feb
The tracing specification and first language SDKs hit stable general availability, providing the first long-term stability guarantees for production adoption.
2021 Mar
AWS made Fault Injection Simulator generally available with templates and alarm-based stop controls.
2021 Apr
Kubernetes 1.21 made EndpointSlice stable, cementing it as the scalable representation of Service backends.
2021 Apr
Releases through 2.2 cemented the Loki-Prometheus-Tempo pairing under Grafana, with LogQL metric queries and ruler-based alerting as first-class features.
2021 Apr
SIG Network published conformance work to compare CNI behavior across NetworkPolicy constructs, highlighting implementation differences beneath one API.
2021 Jul
The project moved from four releases per year to three starting with Kubernetes 1.22. The operational cadence shifted toward fewer, longer release cycles.
2021 Aug
The CNCF TOC promotes OpenTelemetry from sandbox to incubating status, reflecting rapid community adoption and API maturity.
2021 Aug
OpenTelemetry became a CNCF incubating project. Its tracing APIs, SDKs, Collector, and exporters increasingly provided a shared collection path for multiple backends.
2021 Aug
CNCF moved OpenTracing to archived maturity status. The transition signaled that new standardization work had moved to OpenTelemetry.
2021 Sep
The OpenTelemetry protocol changelog marked collector metrics components stable. Metric collection pipelines gained a stable interoperability point.
2021 Sep
The OpenTelemetry project reported its Collector's first general availability release and a tracing stability milestone. Collection, processing, and export became a stable pipeline concern alongside application instrumentation.
2021 Sep
OpenTelemetry reached stable metrics support, letting services emit a single instrumentation standard that feeds Prometheus, managed backends, and tracing systems without per-vendor code.
2021 Oct
The project recommended OpenTelemetry SDKs as they reached feature parity with Jaeger client libraries. This shifted instrumentation investment toward the shared ecosystem.
2021 Oct 8
Polar Signals releases Parca, pairing an eBPF-based profiler that discovers targets through Kubernetes or systemd with storage that identifies profile series by type and key/value labels and queries them with a label selector. Profiles become a queryable time series rather than a file, which is what makes comparing two points in time a query rather than a manual diff.
2021 Dec
Microsoft introduced Azure Chaos Studio as a managed platform for controlled disruption experiments.
2022 Jan
LitmusChaos moved from CNCF Sandbox to incubation as a maintained platform for controlled resilience experiments.
2022 Feb
The whitepaper added data-plane and control-plane material, expanded active-passive failover guidance, and replaced CloudEndure Disaster Recovery with AWS Elastic Disaster Recovery.
2022 Feb
Chaos Mesh moved to CNCF incubation after adding observability, fault types, and workflow support.
2022 Apr
Kubernetes 1.24 removed the in-tree dockershim. Operators with Docker Engine dependencies had to assess runtime and tooling assumptions before upgrading.
2022 May
INP was introduced as an experimental responsiveness metric. It shifted attention from the first input toward responsiveness across a page visit.
2022 May
Jaeger 1.35 added native reception of OpenTelemetry trace data through OTLP. Applications could send OTLP directly to the backend without a Jaeger exporter or a Collector placed only for protocol conversion.
2022 May
The project announced metrics release candidates with shared metadata and semantic conventions alongside tracing. The Collector could also receive OpenTelemetry and Prometheus-compatible metrics.
2022 May
OpenTelemetry announced metrics release candidates for language APIs and SDKs. The Collector could receive both OpenTelemetry and Prometheus- compatible metrics.
2022 May 3
Kubernetes 1.24 finishes the transition begun in 1.20: clusters now need containerd, CRI-O, or another CRI-compliant runtime, with Docker-built images continuing to run unchanged since they follow the OCI image spec.
2022 Dec
Kubernetes 1.26 introduced Dynamic Resource Allocation for requests that need more expressive matching than counted resources.
2023
eBPF-based observability tools moved kernel-level tracing and profiling into mainstream use, letting a troubleshooter ask "where" a process is spending time without instrumenting the application. It widened the "where" question beyond userspace.
2023
Fedora accepts adding `-fno-omit-frame-pointer` and `-mno-omit-leaf-frame-pointer` to default C and C++ compilation flags, targeting Fedora Linux 38. The rationale is that stack unwinding via frame pointers is cheap while the DWARF alternative requires copying the full stack from kernel to user space, against a measured cost of about 2.4% on a kernel compile and 2% on a Blender render. A distribution-wide build flag is changed to make profiling work.
2023 Mar 15
Grafana Labs acquires Pyroscope, founded in 2021, and merges it with Grafana Phlare, launched in 2022, under the name Grafana Pyroscope. The open-source continuous profiling field consolidates from two competing databases into one, alongside the framing of profiling as a further observability signal beside metrics, logs and traces.
2023 Apr
The Prometheus-inspired TSDB index format replaced boltdb-shipper as the recommendation, bringing more efficient, faster, and more scalable index files shipped to object storage.
2023 Apr
The specification defined a common log-record model with timestamps, severity, body, resource, attributes, and trace context. It gives structured logging pipelines a portable vocabulary for record fields.
2023 May
OpenTelemetry reported stable Metrics SDK releases for major languages and began archiving OpenCensus repositories. Existing instrumentation could migrate toward the combined telemetry ecosystem.
2023 Jul
OpenCensus repositories were archived as OpenTelemetry reached feature parity across major language implementations. Migration from separate tracing and metrics projects shifted toward the combined OpenTelemetry ecosystem.
2023 Oct
Gateway, GatewayClass and HTTPRoute graduated to v1, establishing a stable role-oriented routing API.
2024
Vendors began offering AI-assisted root-cause analysis on top of metrics, logs, and traces, ranking hypotheses for a responder. It did not replace the hypothetico-deductive method; it sped the "form hypotheses" step and left testing to the operator.
2024
Error-budget tracking and SLO-based alerting moved from book concept to standard feature in managed observability platforms, closing the loop between the SLO a team negotiates and the alerts that fire when it is consumed.
2024
Google's incident-management guide places postmortems, corrective actions, broad sharing, and aggregate learning in the wider incident lifecycle. It presents blameless learning as part of an operating system for response and improvement.
2024
ISO lists Amendment 1:2024 for ISO 22301:2019. The amendment kept the standard current while its next full edition entered development.
2024 Mar
incident.io combined alerts, schedules, escalation paths, and incident coordination in one product. The launch illustrates the shift toward preserving alert context, escalation history, and resolution work in a shared incident record.
2024 Mar
INP became a stable Core Web Vital and replaced FID. RUM dashboards and release comparisons needed to evaluate responsiveness with the newer metric.
2024 Apr
Kubernetes 1.30 shipped 45 enhancements across stable, beta, and alpha stages. Regular releases continued to make compatibility review and upgrade preparation recurring operational work.
2024 Apr
Version 3.0 introduced structured metadata, attaching high-cardinality key-value pairs to entries without indexing them, required the TSDB index and chunk format v4, and deprecated the Promtail agent, whose code had merged into Grafana Alloy.
2024 May
Gateway API v1.1 added stable GRPCRoute and service-mesh support, extending the portable route model beyond the initial v1 resources.
2024 Jun 6
A decade on, Kubernetes counts more than 88,000 contributors from over 8,000 companies across 44 countries — evidence the desired-state model this course teaches outgrew any one vendor.
2024 Jun 7
OpenTelemetry accepts Elastic's donation of its eBPF-based continuous profiling agent, which observes code across programming languages and runtimes, third-party libraries, kernel operations and system resources without code instrumentation, recompilation or service restarts, at roughly 1% CPU. Profiling gains a vendor-neutral collection agent and a data model that carries the same attributes as traces and metrics.
2024 Aug
Kubernetes 1.31 introduced an updated DRA API and structured parameters so scheduling can reason about ResourceClaims during Pod placement.
2024 Nov
Jaeger 2 introduced a single configurable binary built on the OpenTelemetry Collector framework. The release retained core tracing backend capabilities while changing deployment and configuration assumptions.
2024 Nov
Native OpenTelemetry log ingestion (POST /otlp/v1/logs) became a supported path, and the Loki operator ecosystem matured around Kubernetes deployments.
2025 Nov
SSD mode, the write/read/backend grouping installed by the default Helm chart, was deprecated in favor of HA monolithic mode, with removal scheduled for Loki 4.0.
2026 Mar
The 3.7 line continued the bloom filter work for very large tenants, where bloom planner, builder, and gateway services filter chunks using structured metadata to cut query cost.