This article is based on analysis originally published on JAXenter.com in early 2020, covering software development trends driven by the rise of microservices architectures.
Microservices Complexity: A Problem Worth Solving
The growing popularity of microservices-based applications is no accident. Development teams are drawn to the agility and deployment velocity that microservices enable. However, that agility comes with a real cost: orders of magnitude more independently deployable services, each changing at its own cadence, create complex operational and governance surface areas that can quickly descend into chaos without deliberate countermeasures.
Three concrete trends were forecast to give development teams the upper hand on this complexity in 2020—and they remain highly relevant today.
Trend 1: Go Container-First (and Second, and Third)
The democratization of container technology around 2013 gave developers a powerful new primitive: a self-contained, portable unit of software that cleanly separates the concerns of development (what runs inside the container) from operations (what runs outside the container). That separation has proven enormously practical.
Containers offer three properties that make them attractive across every class of application:
- Portability: A container image runs consistently across different Linux distributions and underlying infrastructure providers—on-premises or in any public cloud.
- Automateability: Container lifecycle operations—build, ship, run, scale, retire—are straightforward to script and integrate into CI/CD pipelines.
- Standardization: Whether the application is a commercial off-the-shelf (COTS) product, a legacy brownfield system, or a modern greenfield microservice, the container becomes the universal unit of work.
A container-first strategy provides a clear, uniform path to the cloud for all application types—not just new ones. Analyst firm Gartner predicted (circa 2019) that more than 75% of global organizations would be running containerized applications by 2022, compared with fewer than 30% in 2019. Whether or not those exact figures proved accurate, the directional trend is well established: container adoption has accelerated dramatically across enterprise organizations.
The practical takeaway for engineering teams is to resist treating containers as an optional optimization for microservices only. Adopting containers as the default packaging and delivery mechanism—regardless of application type—dramatically simplifies complexity by giving every team a shared vocabulary and shared toolchain.
Trend 2: Automate or Die
Standardizing on containers is a necessary first step, but it is not sufficient on its own. Modern software delivery involves a sprawling set of tools: IDEs, version control systems, continuous integration (CI) servers, static analysis tools, vulnerability scanners, artifact registries, and container orchestration platforms. Without automation, developers spend cognitive energy managing toolchains instead of writing software.
Pipeline automation ties these tools together into a repeatable, auditable, fast-feedback delivery loop. A well-automated delivery pipeline typically includes:
- Source control triggers: Every commit automatically kicks off the pipeline.
- Continuous integration: Build, unit test, and static analysis run on every change.
- Security scanning: Container image layers and dependency manifests are scanned for known vulnerabilities before promotion.
- Artifact promotion: Verified images are pushed to a container registry with immutable, traceable tags.
- Continuous delivery or deployment: Promoted artifacts are deployed to staging and production environments with minimal or no manual intervention.
For microservices-based architectures specifically, automation is not optional. Each service has its own release cadence; manual processes collapse under that frequency. Teams that invest in robust pipeline automation in 2020 and beyond are the ones positioned to ship reliably at the pace microservices demand.
Trend 3: Reuse Over Reinvention
Even with containers and automation in place, developer time remains the ultimate constraint. Demand for software consistently outpaces the supply of engineers. One powerful way to close that gap is to maximize reuse of existing, battle-tested code rather than building from scratch each time.
Container image registries like Docker Hub illustrate this behavior at scale. At the time this analysis was published, Docker Hub was reportedly handling approximately two million image searches per day and six billion image pulls per month—a strong signal that developers actively look for existing solutions before writing their own. These figures were cited from Docker’s own reporting and have not been independently verified here.
The container model makes reuse structurally easier than earlier approaches:
- A container image bundles all runtime dependencies, so a reused image behaves the same in your environment as in its source environment.
- Public and private registries provide searchable catalogs of pre-built service images covering databases, message brokers, API gateways, observability agents, and much more.
- Internal platform teams can publish curated, security-hardened base images that product teams build on top of, reducing duplicated hardening effort across the organization.
As microservices architectures mature inside organizations, the expectation is that an increasing proportion of services in any new application will be assembled from existing, reusable components rather than written from scratch. This shifts the developer’s primary skill from authoring every line of code to selecting, composing, and integrating reliable components—a meaningful evolution in how software is built.
Putting It All Together
These three trends are mutually reinforcing. Container-first standardization establishes a common unit of work. Pipeline automation makes operating at the pace of microservices feasible. Reuse accelerates delivery by reducing the volume of new code that must be written, tested, and hardened.
Organizations that treat all three as foundational—rather than as nice-to-have optimizations—are best positioned to capture the agility benefits that microservices promise without drowning in the operational complexity they introduce.
For DevOps teams planning their toolchain and process investments, 2020 marked the point where these practices moved from early-adopter territory to mainstream expectation. Teams that have not yet formalized container-first pipelines and reuse strategies should treat closing that gap as a high-priority initiative.