This article is based on a DevOps industry outlook originally published in late 2017, drawing on trends observed through that year. It is presented here as a historical snapshot and a baseline for understanding how the DevOps landscape has evolved.
Context: DevOps Adoption Was Already Accelerating
By the end of 2017, DevOps had moved well beyond early-adopter territory. More industries were integrating the cultural practices, automation tooling, and cross-functional collaboration that define DevOps. The demand for engineers with DevOps expertise was growing globally, and the question was no longer whether to adopt DevOps, but how fast and how deeply.
Against that backdrop, five clear trends were emerging as the industry headed into 2018.
1. DevSecOps: Security Moves Left in the Pipeline
Traditional software delivery models treated security as a gate at the end of the release cycle — a final audit before shipping. DevSecOps challenges that model by integrating security practices, tooling, and team ownership directly into the development pipeline from the very first sprint.
The practical benefits are significant:
- Earlier vulnerability detection: Architectural flaws and misconfigured dependencies are far cheaper to fix at design time than after deployment.
- Automated compliance checks: Static analysis, dependency scanning, and container image scanning can run as part of a CI pipeline rather than as a manual, pre-release ceremony.
- Shared ownership: Security becomes a first-class engineering concern rather than a separate department’s bottleneck.
The integration of security into DevOps pipelines has only deepened since 2018. Tools like Snyk, Trivy, and HashiCorp Vault are now standard parts of modern CI/CD toolchains, and the phrase “shift left” has become ubiquitous in security-aware engineering organisations.
2. DevOps Expands Into IoT: Software-Defined Hardware
As connected devices proliferated, hardware manufacturers found themselves maintaining software at a scale and cadence they had not previously experienced. The IoT context makes DevOps principles essential rather than optional: a device shipped to a customer is not the end of the product lifecycle — it is the beginning of an ongoing software relationship.
Tesla’s over-the-air (OTA) software update model was frequently cited as the leading example. By treating the vehicle’s software stack as a continuously delivered product, Tesla was able to push performance improvements, new features, and safety corrections to existing vehicles without requiring a physical recall. Legacy automotive manufacturers, by contrast, have been forced to manage traditional recall processes for issues that could theoretically be resolved via a software patch.
The broader lesson for IoT product teams:
- Plan for continuous delivery of firmware and software from day one.
- Design device update mechanisms (OTA, staged rollouts, rollback) as core product features.
- Treat field monitoring and telemetry as integral to your release feedback loop.
3. Monitoring Becomes the New Testing
At scale, exhaustive pre-release testing of every conceivable scenario is neither practical nor sufficient. No test suite can fully simulate the unpredictable combinations of load, user behaviour, and infrastructure state that production environments produce.
The shift in thinking: rather than relying solely on tests that check for problems you anticipated, invest heavily in observability systems that surface problems you did not anticipate — as they occur in production.
Netflix was already a widely cited example of this approach. Its engineering teams built internal tools to proactively detect infrastructure components that fell outside expected performance envelopes and replace them automatically, rather than waiting for failures to escalate to outages. This philosophy — sometimes called “chaos engineering” when applied deliberately — treats production as the ultimate test environment.
Key capabilities that support a monitoring-first culture include:
- Distributed tracing (e.g., Jaeger, Zipkin, OpenTelemetry) to follow requests across microservices.
- Structured logging aggregated into searchable platforms (e.g., the ELK stack, Loki).
- Real-time metrics and alerting (e.g., Prometheus + Grafana, Datadog).
- SLO-based alerting that ties operational alerts to user-facing reliability targets.
4. Kubernetes Becomes the Standard for Container Orchestration
In 2017–2018, the container orchestration landscape was still competitive, with Docker Swarm and Apache Mesos vying for adoption alongside Kubernetes. By the end of 2018, Kubernetes had effectively won that contest, and major cloud providers — including Microsoft Azure (AKS), Amazon Web Services (EKS), and Google Cloud (GKE) — all offered managed Kubernetes services.
The managed Kubernetes model introduced a meaningful shift for engineering teams: much of the operational burden of running and upgrading the Kubernetes control plane moved to the cloud provider, allowing teams to focus on application layer concerns rather than cluster infrastructure.
Predictions from this period that proved accurate:
- Kubernetes became the de facto PaaS substrate, enabling standardised deployment patterns across organisations of all sizes.
- An ecosystem of extensions (operators, Helm charts, service meshes) grew rapidly around the core platform.
- Monitoring, logging, and metrics tooling matured significantly as the community converged on standard interfaces (e.g., the Prometheus metrics format).
The prediction about “serverless Kubernetes” also materialised in the form of offerings such as AWS Fargate (for EKS) and Azure Container Instances, where node management is abstracted away entirely.
5. The Declining Role of Traditional Server Operating Systems
As workloads migrated into containers and container-native platforms, the role of the traditional general-purpose server operating system began to shrink. Instead of a full Linux or Windows Server installation maintained by operations teams, container hosts increasingly run minimal, purpose-built operating systems — such as Flatcar Container Linux or Bottlerocket — designed specifically to run container runtimes and nothing else.
This trend continues in managed Kubernetes environments, where the node operating system is largely invisible to the application development team. Developers interact with the Kubernetes API; the underlying OS is a concern of the cloud provider.
The broader implication is a continued layering of abstraction: from physical hardware, to virtual machines, to container runtimes, to orchestration platforms, to application frameworks — with each layer reducing the operational surface area that a given team needs to manage directly.
Looking Back: How Accurate Were These Predictions?
Assessed from the vantage point of several years later, the five trends identified heading into 2018 were broadly correct in direction, even if the pace and shape of change varied:
- DevSecOps is now mainstream. Automated security scanning is a standard CI/CD pipeline component in security-conscious organisations.
- IoT DevOps has grown in importance, though the industry still struggles with fragmented tooling and long device support lifespans.
- Monitoring and observability have become central engineering disciplines, with OpenTelemetry emerging as a unifying standard.
- Kubernetes did indeed become the standard. The container orchestration wars are over.
- Traditional OS abstraction has continued, particularly in serverless and fully managed container environments.
Key Takeaways for DevOps Teams
Whether you are reviewing this as historical context or orienting yourself in the current DevOps landscape, the underlying principles remain consistent:
- Integrate security early — shifting left is cheaper and more effective than bolt-on audits.
- Treat all connected products, including hardware, as software delivery problems requiring continuous updates.
- Invest in observability infrastructure as seriously as you invest in your test suite.
- Adopt Kubernetes or a managed equivalent to standardise container workload management and reduce operational overhead.
- Embrace higher layers of abstraction, but maintain enough understanding of the layers below to debug them when abstractions leak.
The DevOps movement continues to expand both in breadth — across industries and organisational functions — and in depth, as practices mature and tooling consolidates. The trajectory identified at the end of 2017 remains a useful map of where the industry was heading.