This article is based on insights originally shared by Daniel Berman, Product Marketing Manager at Logz.io, via DevOps Online. Logz.io is an Israeli and US-based organisation that combines cloud services with machine learning to provide data visualisation for platforms and applications.
Introduction
DevOps is a discipline that evolves rapidly — practices, tooling, and cultural norms shift almost continuously. Looking back at 2019, several clear trends emerged that defined how engineering teams built, secured, and operated software at scale. Below is a structured breakdown of the ten most significant DevOps trends from that year, many of which continue to influence the industry today.
1. Pipeline Automation
Automation has always been central to DevOps philosophy, and 2019 saw it deepen further. Continuous integration and continuous delivery (CI/CD) tooling continued to proliferate, with GitHub’s introduction of GitHub Actions expanding the ecosystem of pipeline automation options available to teams.
Closely tied to CI/CD growth is the maturation of infrastructure as code (IaC). Tools such as Terraform, AWS CloudFormation, Azure Resource Manager, and GCP’s Deployment Manager became standard practice, allowing teams to provision and tear down environments programmatically — whether during local development, inside CI pipelines, or even in production delivery workflows.
2. Kubernetes Dominance
Kubernetes was virtually inescapable in 2019. Since its release in 2014 and general availability in 2015, it established itself as the leading container orchestration platform, accumulating far more community mindshare than competitors such as Apache Mesos or Docker Swarm.
Major enterprise vendors including Red Hat and VMware committed deeply to Kubernetes support, and an increasing number of software vendors began shipping their products with Kubernetes-native deployment as the default. While Kubernetes had not yet proven itself universally across every class of workload, the momentum behind it remained strong heading into 2020.
3. Service Meshes
As Kubernetes adoption expanded, so did conversations about service meshes. A service mesh is software that manages service-to-service communication within a distributed platform. Rather than requiring each application team to implement their own solutions for common concerns, a service mesh provides these capabilities at the platform level.
Typical service mesh capabilities include:
- Load balancing
- Mutual TLS encryption
- Authentication and authorisation
- Traffic proxying and routing
- Observability and tracing
By moving these concerns out of application code and into the platform layer, service meshes free development teams to focus on business logic rather than distributed systems boilerplate.
4. Observability
Observability is frequently conflated with monitoring, but the distinction is important. Monitoring is an activity — you monitor a system. Observability is a property of a system — it describes whether the internal state of that system can be reliably inferred from its external outputs.
The concept originates in control theory and real-world engineering. For software systems, high observability means that when something goes wrong, engineers can determine the root cause quickly from the data the system already emits — logs, metrics, and traces — without needing to instrument it further after the fact.
Related to observability is the concept of cardinality — the number of distinct values in a time-series dataset. Higher cardinality generally means more granular data, which supports more precise troubleshooting. However, high-cardinality data also carries storage and query costs, so teams must balance richness of data against operational overhead.
5. DevSecOps
Security traditionally sat outside the development pipeline — something applied as a gate at the end, or retrofitted after incidents. DevSecOps challenges this by integrating security practices directly into CI/CD pipelines and making security a shared responsibility across development, operations, and SRE teams.
Key developments in this space in 2019 included:
- Compliance as code tools such as InSpec, which allow security and compliance checks to be written, versioned, and run automatically as part of pipelines.
- Container image scanning tools such as Aqua Security and Sysdig, which inspect images for known vulnerabilities before they are deployed.
- Growing awareness of the need to embed security at every stage of the software delivery lifecycle rather than treating it as a final checkpoint.
The broader portmanteau “DevSecNetQAGovOps” was occasionally floated to describe even more holistic pipeline integration, though DevSecOps remained the dominant and most practical framing.
6. The Rise of Site Reliability Engineering (SRE)
Site Reliability Engineering (SRE) is a discipline that originated at Google in 2003 — predating the term “DevOps” entirely. It was later documented in Google’s book Site Reliability Engineering. The core idea is to treat operations as a software engineering problem: SRE teams write code to automate reliability, define error budgets, and maintain service level objectives (SLOs).
Unlike a traditional DevOps team structure where one team owns the full lifecycle, SRE acknowledges that at very large scale, a dedicated reliability engineering function may be necessary. At Google’s scale — hundreds of data centres, vast standardised infrastructure — a single cross-functional team owning every service end-to-end is not practical.
In 2019, job postings for “SRE Engineer” roles reportedly began to outnumber those for “DevOps Engineer” at many organisations. This reflects both the growing influence of the SRE model and a desire by organisations to signal a specific, engineering-focused operational capability.
7. Artificial Intelligence and Machine Learning in DevOps
The application of machine learning (ML) to DevOps tooling began gaining traction in 2019, though the space was still early-stage. Emerging use cases included:
- Anomaly detection: ML models trained on historical application behaviour to flag deviations that may indicate incidents before they escalate.
- Test optimisation: Using ML to determine which test cases are most likely to catch regressions on a given build, reducing CI pipeline duration without sacrificing coverage.
- Predictive infrastructure management: Google published research on using ML models to predict hardware failures ahead of time, enabling proactive remediation.
Products such as ScienceLogic’s SL1 were early entrants in the AI-assisted operations (AIOps) market. The category was still nascent, but directionally significant.
8. Serverless Computing
Serverless computing — popularised by AWS Lambda when it launched in 2014 — continued to grow in 2019 as other cloud providers and open-source projects expanded the ecosystem. The term “serverless” can be misleading: servers are still involved. What it actually means is that the developer does not manage server provisioning or scaling. The cloud provider handles infrastructure entirely; the developer deploys code and pays for execution time.
Key considerations for serverless adoption include:
- Vendor lock-in: Serverless applications are typically tightly coupled to the platform they run on, making portability a genuine concern.
- Cold start latency: Functions that have not run recently may incur startup delays.
- Use-case fit: Serverless suits event-driven, short-lived workloads well, but is less suited for long-running or stateful processes.
9. Shifting Left and Shifting Right in CI/CD
As release cycles shortened, the concepts of shift-left and shift-right testing gained wider recognition.
Shift left refers to moving quality checks earlier in the development process — catching problems as close to the point of authorship as possible. This includes not just unit and integration testing, but also code linting, static analysis, dependency vulnerability scanning, and security checks. The earlier a defect is caught, the cheaper it is to fix.
Shift right refers to testing in production or production-like environments, intentionally surfacing issues that only manifest at scale or under real user traffic. Techniques include canary deployments, feature flags, chaos engineering, and synthetic monitoring. The goal is to discover failure modes before users report them.
10. The CALMS Framework as a Unifying Lens
While not a new trend in 2019, the CALMS framework — standing for Culture, Automation, Lean, Measurement, and Sharing — provided a useful lens through which to evaluate all of the above trends. Each of the nine trends described above can be mapped to one or more of these principles:
- Culture: DevSecOps, SRE, and the organisational changes they require
- Automation: Pipeline automation, IaC, and serverless
- Lean: Shift-left testing, reducing waste in release cycles
- Measurement: Observability and AI-assisted monitoring
- Sharing: Kubernetes ecosystems, service meshes, and open tooling
Summary
The DevOps landscape in 2019 was characterised by the maturation of container orchestration, growing security integration, and the early application of machine learning to operational problems. Many of these trends — Kubernetes, observability, DevSecOps, and SRE — have since become foundational rather than emergent. Understanding where they stood in 2019 provides useful context for appreciating how far the discipline has evolved since.