From YAML to Platforms: The Kubernetes Deployment Journey

Platforms provide self-service and intuitive abstractions for developers and consolidate tools under a unified management layer for ops teams.

May 29th, 2025 11:00am by Bhushan Nemade

Featued image for: From YAML to Platforms: The Kubernetes Deployment Journey

Image from iralu on Shutterstock.

The promise of Kubernetes — agility, scalability and reliability — has driven its widespread adoption across enterprises. The Cloud Native Computing Foundation 2024 annual survey reported that 93% of organizations are either using or evaluating it. However, deploying and managing applications to Kubernetes environments has been far from static. Organizations have undergone a significant evolution, from elementary beginnings to automated practices. This evolution has changed the question for organizations from “Can we run applications on Kubernetes?” to “How to optimize application delivery in complex Kubernetes environments?” Let’s explore the journey most organizations have taken to achieve excellence in Kubernetes deployments and application management.

The Start of the Journey — Kubernetes Manifests

Every organization’s journey to Kubernetes typically starts with one thing: YAML files — and lots of them. These Kubernetes manifests are foundational, offering detailed, declarative control over every aspect of a deployment. From configuring resources to defining service behaviors, YAML files serve as the blueprint for deploying and managing applications in Kubernetes. Here’s a sample manifest for a deployment object. Kubernetes Manifest (example-app.yaml)

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: app-container
        image: example:1.0.0
        ports:
        - containerPort: 8080
```

However, these Kubernetes manifests revealed their limitations at scale. When the organization decided to scale to Kubernetes, management of these Kubernetes manifests started to become a bottleneck. Some key limitations that organizations faced were:

Version control challenge: Tracking changes across hundreds of YAML files becomes a maintenance nightmare.
Configuration drift: Environment-specific variations multiply rapidly.
Lack of standardization: Different teams develop their manifest patterns, creating organizational silos.
Security governance: Ensuring consistent security controls becomes nearly impossible.
Operational complexity: Troubleshooting requires deep diving into raw YAML files.

These limitations highlighted the need for a higher level of abstraction on top of Kubernetes manifests, one that could help organizations manage YAML files more efficiently while providing a standardized way of working, all without compromising the power and flexibility of Kubernetes.

Standardizing the Kubernetes Manifests — Helm

The emergence of Helm, a package manager for Kubernetes, marked a significant step forward in orchestrating Kubernetes manifests. It introduced the concept of charts, which bundle all the required Kubernetes resources into a single, reusable package. The templating capability of Helm charts makes it easier for teams to manage the configuration and enable customization of deployments of large applications. Deploying complex applications became less about wrangling individual manifests and more about managing well-defined, versioned artifacts. For organizations, this translates into improved consistency across environments and the ability to define application life-cycle management more effectively. Helm Chart

Mychart
|-- Chart.yaml
|-- charts
|-- templates
|   |-- NOTES.txt
|   |-- _helpers.tpl
|   |-- deployment.yaml
|   |-- ingress.yaml
|   `-- service.yaml
`-- values.yaml

However, for mature organizations operating at scale, the adoption of Helm often unveils certain limitations that need careful consideration:

Complexity of templating logic: While templating offers flexibility, overly complex Helm charts can become difficult to understand, maintain and debug.
Complexity in managing nested charts: Users often encounter difficulties when working with heavily nested Helm charts. Understanding at which level to set values in the `values.yaml` file can be confusing, especially when dealing with upstream charts that have their own architectures.
Lack of automated deployment workflow: Helm primarily focuses on packaging and deploying prebuilt application artifacts (charts). It doesn’t inherently define or automate the process of building those artifacts from source code, running tests or managing the release pipeline across different environments.
Lack of visibility and monitoring: Helm CLI does not provide a built-in mechanism to view the health and status of applications deployed through its charts.

With all the pros and cons of Helm, it gave organizations a way ahead to deploy and manage their application over Kubernetes in a simplified way that handles lots of raw Kubernetes manifests.

Automating Delivery Pipelines — CI/CD Integration

By the time Kubernetes had gained widespread adoption, organizations had already figured out how to deploy and run their applications on it. The next challenge was no longer about how to run applications, but how to deliver the frequent changes into these increasingly complex Kubernetes environments. To gain a competitive edge and rapidly meet evolving customer demands, organizations needed to release new features and bug fixes with increasing frequency, often multiple times daily. This necessitated the integration of CI/CD pipelines into Kubernetes workflows. With CI/CD, organizations have automated the process of building, testing and deploying. Using tools to apply manifests or Helm charts significantly reduced manual errors and accelerated time to market. Tools like Jenkins and Circle CI were being used for building the applications and for deployments, and kubectl or Helm were the only options. Later, the capabilities of the Jenkins organization extended the use of Jenkins to execute `kubectl apply` and update the image tag in `values.yaml` of the Helm chart.

The GitOps Approach

To strengthen the deployment part, an approach specifically designed for Kubernetes came into existence: GitOps. It defines four core pillars of executing deployments specifically on Kubernetes:

Declarative
Versioned and immutable
Pulled automatically
Continuously reconciled

GitOps offers compelling advantages in enhanced security (audit trails, immutable infrastructure), improved compliance (declarative state) and increased operational resilience (automatic reconciliation and self-healing). Facilitating the adoption of GitOps for Kubernetes teams, tools such as Argo CD and Flux CD provide the necessary automation and control for declarative, versioned and continuously reconciled deployments. Later on, to enhance the reliability of Kubernetes deployments and upgrades, the concept of progressive deployments emerged. This approach introduced various deployment strategies designed to minimize disruptions during application updates. Advanced techniques such as blue-green and canary deployments became key methods to achieve seamless rollouts.

The New Bottleneck

At this stage, the evolution of Kubernetes deployments looks logically completed: starting from the raw Kubernetes manifests, to the orchestrating power of Helm, the automation of CI/CD, and finally GitOps to deploy changes reliably. This might be a perfect picture for teams operating at a small scale, but when the scale increases, the stakes are high, and the above so-called perfect picture becomes a bottleneck. Teams now have to deal with the new challenge: tool sprawl. Even if you have an exceptional operations team, they can now wield tools at different levels to abstract complexities and operate smoothly with multiple tools. But what about the developers who have to deploy their code multiple times across various environments during the development life cycle? From local setups to shared dev and staging instances, the deployment landscape for developers often remains far from streamlined.

The Platform Approach

For the majority of tech organizations reaching significant scale, the inherent complexity of cloud native technologies presented a dual challenge. Operations teams found themselves increasingly burdened by a set of tools, while developers struggled with the friction of deploying code quickly and efficiently. This situation created a vicious cycle: Developers constantly raised tickets for pipeline setup, while operations teams struggled under the mounting backlog. Developer frustration grew with each delay, ultimately crippling the organization’s productivity and defeating the efficiency gains Kubernetes was meant to deliver. In 2010, industry giants like Airbnb, Netflix and Google started to build their own internal platforms intended to help developers and operations teams work more efficiently. The platform approach was to simplify things for developers and reduce their cognitive load, which is where the self-service approach fits perfectly. The landscape of platforms has evolved significantly, with multiple platforms that address these challenges from both sides. For developers, they provide self-service capabilities and intuitive abstractions at multiple levels, eliminating wait times. For operations teams, they consolidate tooling under a unified management layer, enabling governance without becoming a bottleneck. One such platform is Devtron, a Kubernetes application life-cycle management solution. Its intuitive UI abstracts away complexity for developers, providing a self-service approach that empowers them to deploy applications across environments through GitOps-enabled CI/CD pipelines, without requiring operational intervention. Simultaneously, Devtron addresses operational challenges by consolidating disparate tools under a unified interface, offering a single pane of glass for managing multiple Kubernetes clusters.

Conclusion

The path of deploying and managing applications on Kubernetes has been a dynamic evolution, marked by increasing levels of abstraction and automation. Organizations have continuously sought more efficient, reliable and scalable methods, from the foundational control of raw manifests to the orchestration of platforms. While significant progress has been made in streamlining these processes for both development and operations teams, the journey continues, driven by the ever-evolving demands of modern software delivery.

Bhushan Nemade is an OSS evangelist at Devtron, passionate about driving open-source adoption and innovation. He enjoys contributing to open-source projects and writing about them to empower the community.