Originally written in late 2019, this article examines the DevOps predictions that were expected to define 2020. While some predictions proved accurate, others took longer to fully materialize. The article is preserved here as a useful reference for understanding how the DevOps landscape was evolving at that time.
Why 2020 Was a Pivotal Year for DevOps
DevOps has traveled a long way from being dismissed as a buzzword. By the end of the 2010s, it had become a strategic priority for enterprises of all sizes, reshaping how software is built, tested, and delivered. Senior leaders shifted their view of DevOps from a tool for marginal efficiency gains in isolated projects to a driver of genuine innovation and organizational transformation.
Market research from IDC forecast that the worldwide DevOps software market would grow from approximately $2.9 billion in 2017 to $6.6 billion by 2022, reflecting the scale of enterprise investment in DevOps tooling, training, and culture change.
With that backdrop, here are the five major trends that analysts and practitioners predicted would define DevOps in 2020.
Trend 1: AI and Machine Learning Enter the DevOps Pipeline
Automation has always been central to DevOps, but the next step beyond scripted automation is intelligent automation — systems that learn from historical data and adapt their behavior accordingly. In 2020, AI and machine learning were expected to take on a more active role across the CI/CD pipeline.
Practically, this meant:
- Predictive code analysis: Using activity logs and repository history to predict where new code changes are likely to introduce bugs, before tests even run.
- Automated test generation: AI-assisted tools generating and prioritizing functional, acceptance, and regression tests based on code change patterns.
- Anomaly detection in pipelines: ML models identifying unusual patterns in build logs, deployment metrics, and runtime telemetry to flag issues earlier than rule-based alerting.
- Infrastructure as Code assistance: AI tools using log data and environment state to suggest or generate IaC configurations, reducing the manual burden on operations teams.
The underlying driver is data volume. DevOps pipelines produce enormous amounts of structured and semi-structured data — build logs, test results, deployment records, and runtime metrics — that are well-suited to pattern recognition techniques. Making productive use of that data became a genuine competitive differentiator.
Trend 2: Serverless Architecture Matures as a DevOps Enabler
Serverless does not mean the absence of servers — it means that server provisioning, scaling, and maintenance are abstracted away by a cloud provider. Development teams deploy code, and the platform handles the rest. The two primary models are:
- Function-as-a-Service (FaaS): Discrete functions triggered by events (e.g., AWS Lambda, Google Cloud Functions, Azure Functions). Teams write small, single-purpose units of business logic without managing runtime infrastructure.
- Backend-as-a-Service (BaaS): Managed services for common backend capabilities such as authentication, databases, and file storage (e.g., Firebase, AWS Amplify).
From a DevOps perspective, serverless reduces operational overhead significantly. Teams spend less time managing infrastructure and more time shipping features. It also aligns naturally with event-driven architectures, making it a good complement to microservices. Cost models shift to consumption-based billing, which can reduce expenses for workloads with variable or unpredictable traffic patterns.
The trade-offs — cold start latency, vendor lock-in, limited execution duration, and observability challenges — mean serverless is not universally applicable, but its role in DevOps workflows continued to grow through 2020 and beyond.
Trend 3: Low-Code DevOps Tooling Lowers the Pipeline Barrier
Even with mature CI/CD tooling, configuring pipelines has traditionally required hands-on technical work: writing YAML files, defining job specifications, maintaining Helm charts for Kubernetes deployments, and scripting policy enforcement. This creates a knowledge bottleneck — only engineers familiar with the underlying tooling can contribute meaningfully to pipeline design.
Low-code DevOps platforms aim to change that by providing visual, point-and-click interfaces for defining and managing pipelines. The benefits for larger engineering organisations include:
- Wider team participation in pipeline configuration, reducing dependency on a small group of CI/CD specialists.
- Faster onboarding for teams adopting DevOps practices for the first time.
- Reduced risk of misconfiguration caused by complex, hand-maintained YAML.
- Easier enforcement of organisational policies and standards across multiple teams.
This trend connects to a broader industry theme: making DevOps capabilities accessible beyond senior platform engineers, without sacrificing the flexibility and power that complex pipelines require.
Trend 4: The Continued Migration from Monolithic to Microservices Architecture
Monolithic applications — where all components of a system are tightly coupled and deployed as a single unit — present significant challenges in a DevOps context. A change to any part of the application requires building, testing, and deploying the entire monolith. This slows delivery cycles and increases the blast radius of any deployment failure.
Microservices architecture addresses this by decomposing applications into small, independently deployable services, each responsible for a specific business capability. The alignment with DevOps is natural: smaller codebases are easier to test, smaller deployments are lower risk, and independent services can be owned end-to-end by small, autonomous teams.
Well-known organisations including Amazon, Netflix, Uber, and Google have publicly discussed their adoption of microservices to enable faster, more reliable software delivery at scale. Their experiences demonstrated that the architectural shift, while complex to execute, pays dividends in deployment frequency and system resilience.
Key considerations when migrating to microservices include service discovery, inter-service communication, distributed tracing, and data consistency — all areas where DevOps tooling (container orchestration, service meshes, observability platforms) plays a critical role.
Trend 5: DevSecOps Embeds Security Across the Entire Pipeline
Traditional software development models treated security as a phase at the end of the development cycle — a gate before release. This approach is incompatible with the continuous delivery cadences that DevOps enables. By the time a security review occurs, resolving findings is expensive and time-consuming.
DevSecOps — the integration of security practices directly into the DevOps workflow — addresses this by shifting security left, making it part of every stage from code commit to production deployment. In practice this includes:
- Static Application Security Testing (SAST): Automated code scanning on every pull request to identify vulnerabilities before code is merged.
- Dependency scanning: Automated checks for known vulnerabilities in third-party libraries and packages.
- Container image scanning: Analysing container images for OS-level and package-level vulnerabilities before deployment.
- Policy-as-code: Encoding security and compliance requirements as machine-readable policies enforced automatically in the pipeline.
- Runtime security monitoring: Continuous monitoring of running workloads for anomalous behaviour.
The benefits of this approach extend beyond risk reduction. Teams that find and fix vulnerabilities early — rather than in a pre-release scramble — spend less time on remediation and more time building features. Security becomes a shared responsibility across development, operations, and security teams rather than a bottleneck owned by a single function.
How These Trends Played Out
Looking back from a post-2020 perspective, all five of these trends did accelerate through the year, though at different rates. DevSecOps and the shift to microservices saw broad enterprise adoption. Serverless grew steadily, particularly for event-driven workloads. AI-assisted DevOps tooling made meaningful progress, with several major platforms integrating ML-based insights into their products. Low-code pipeline tooling gained traction, particularly in larger organisations standardising their internal developer platforms.
Together, these shifts reflect a maturing discipline: DevOps moving from cultural aspiration to engineering infrastructure, supported by increasingly sophisticated tooling and embedded across more of the software delivery lifecycle.