This article is based on a 2017 industry outlook originally sourced from itproportal.com. It has been rewritten and expanded for technical clarity. Some predictions are assessed with the benefit of hindsight.
Containers Were Just Getting Started
In early 2017, containers had already moved from curiosity to conversation topic in most engineering organizations. Docker had existed for only a few years, yet it felt like an established technology — a sign of how quickly the ecosystem was evolving. New tools were appearing daily, and just as many were disappearing. The container space was, and remains, fast-moving.
But by 2017, the interesting question was no longer what are containers? Most teams had completed a proof of concept. The real question had become: what comes next?
The Rise of Container Orchestration
The most significant predicted shift for 2017 was the move from simply running containers to scheduling and orchestrating them at cluster scale. Using containers to standardize development and testing environments was valuable, but the larger gains come when containers are deployed across distributed clusters with proper scheduling.
Three platforms were expected to become mainstream:
- Docker Swarm — Docker’s native clustering and scheduling tool, favored for its simplicity and tight Docker integration.
- Kubernetes — Originally developed at Google, Kubernetes provides sophisticated scheduling, self-healing, service discovery, and rolling updates.
- Apache Mesos — A general-purpose cluster resource manager capable of running containers alongside other workloads.
The prediction was that 2017 would be the year companies left the PoC phase and committed to container orchestration at scale. In retrospect, this proved accurate: Kubernetes in particular saw explosive adoption through 2017 and 2018, and eventually emerged as the dominant container orchestrator. The “battle for the uber orchestrator” the article anticipated did play out, with Kubernetes ultimately prevailing.
Alongside scheduling, the industry expected to see the rise of self-healing systems — clusters that automatically detect and recover from node or container failures without human intervention. Kubernetes readiness and liveness probes, along with its ReplicaSet controller, are the primary implementation of this idea today.
Continuous Deployment Becomes Practical
Continuous deployment (CD) had been a theoretical goal for years, discussed at conferences but rarely practiced end-to-end in enterprise environments. The prediction for 2017 was that container adoption would act as a forcing function: as companies built container-based infrastructure, they would also revisit and finally implement CD pipelines.
Importantly, the outlook emphasized that tooling alone would not solve the problem. Enterprises would need to recognize that CD requires architectural change — particularly a move toward microservices and independently deployable components. Monolithic applications are difficult to continuously deploy regardless of how sophisticated the pipeline tooling is. Companies would need to refactor services to align with cloud-native, cluster-based deployment models.
This insight aged well. The GitOps movement, the growth of tools like Argo CD and Flux, and the widespread adoption of feature flags and progressive delivery all reflect the same realization: deployment automation is a cultural and architectural challenge as much as a technical one.
Unikernels: Stepping Out of the Shadows
One of the more speculative predictions was the emergence of unikernels. A unikernel is a single-purpose operating system image that packages only the kernel components an application actually needs, compiled together with the application itself. The result is an extremely small, fast-booting, and potentially more secure deployable unit.
Unikernels were expected to unify some of the properties of virtual machines (strong isolation) and containers (small footprint, fast startup). The prediction was measured: unikernels would not take the world by storm in 2017, but would gain visibility and lay groundwork for broader adoption.
In practice, unikernel adoption has remained limited as of this writing, constrained by tooling maturity and the difficulty of debugging compared to conventional operating systems. However, the concept continues to influence work in WebAssembly runtimes and specialized edge computing environments.
Machine Learning Enters the Mainstream
In early 2017, machine learning was still concentrated in a small number of large technology companies and research institutions. The prediction was that 2017 would see ML capabilities extend to a much broader range of organizations, with companies beginning to invest in dedicated ML teams and infrastructure.
This trajectory proved correct. The availability of cloud-based ML services (from AWS, Google Cloud, and Azure), the maturation of frameworks such as TensorFlow and PyTorch, and the growth of MLOps as a discipline all reflect the broader democratization that was anticipated.
What Would Fade: Operating Systems, Configuration Management, and Provisioning
Just as interesting as what would rise is what was predicted to decline in relevance:
- Traditional operating systems — As immutable container images and potentially unikernels take hold, the choice of underlying OS becomes less important to application developers. Lightweight Linux distributions suitable for container hosts (such as Alpine-based images or minimal OS variants) were expected to gain ground over full distributions.
- Configuration management tools — Tools designed to configure and maintain persistent servers (such as Chef, Puppet, and Ansible in server-management roles) were expected to lose relevance as immutable infrastructure and container scheduling replaced the model of long-lived, hand-configured servers.
- Manual server provisioning — With schedulers handling workload placement, the concept of provisioning and configuring individual servers would become a concern of platform teams, not application developers.
The core idea is that developers’ lowest-level operational concern would shift upward to the scheduler API — specifying resource requirements (CPU, memory) and letting the platform handle placement and lifecycle. Infrastructure below that level becomes a commodity.
This prediction is directionally correct and is visible in the growth of managed Kubernetes services and serverless platforms, where developers interact almost entirely at the application and workload level.
Go as the Language of Distributed Systems
The Go programming language was predicted to move from open source projects into enterprise engineering organizations in 2017, driven by the growth of microservice architectures and distributed systems. Go’s properties make it well-suited for this context:
- Statically compiled binaries with no runtime dependency
- Low memory footprint compared to JVM-based languages
- Built-in concurrency primitives (goroutines and channels)
- Fast compile times
- Strong standard library for networking and HTTP
The prediction has largely held. Go is now widely used for infrastructure tooling (Docker, Kubernetes, Terraform, and Prometheus are all written in Go) and for backend microservices, particularly where performance and small container image size matter.
Decentralized Tooling and the Open Source Advantage
The final trend anticipated was a shift in how organizations make technology decisions. As polyglot architectures and microservices allow different teams to choose different stacks, centralized mandates for a single language, framework, or vendor become harder to enforce — and arguably less beneficial.
The prediction was that tooling decisions would become more decentralized, favouring open source solutions over proprietary enterprise software. This shift was expected to make it harder for software vendors to sell monolithic platform solutions.
This trend is visible in the CNCF (Cloud Native Computing Foundation) ecosystem, where a large number of open source projects compete and interoperate, and organizations assemble their own stacks rather than purchasing an integrated suite from a single vendor.
Summary: Which Predictions Held Up?
| Prediction | Outcome |
|---|---|
| Container orchestration (Kubernetes, Swarm, Mesos) goes mainstream | Accurate — Kubernetes became dominant |
| Continuous deployment becomes more practical | Accurate — tooling and GitOps practices matured |
| Unikernels step into the spotlight | Partially — adoption remained limited |
| Machine learning reaches broader audiences | Accurate |
| OS and config management tools decline in developer relevance | Directionally accurate |
| Go becomes the language of distributed systems | Accurate |
| Decentralized, open source tooling wins | Accurate — CNCF ecosystem growth |
Looking back, this set of predictions captured many of the directions the industry actually moved. The container orchestration consolidation around Kubernetes, the rise of Go, and the practical maturation of continuous deployment pipelines all unfolded broadly as anticipated. Unikernels remain the notable exception — an area where the technical promise has not yet translated into widespread adoption.