GuidesChangelogDiscussions
Log In

Ketch improves the developer experience and productivity by implementing a standard application-level definition.

Ketch logoKetch logo

Why Ketch

Today, there is no standardized application-level definition you can use across Infrastructure-as-Code (IaC) tools or pipelines to deliver applications across different clusters, providers, and versions, forcing DevOps teams to constantly create and manage a myriad of templates that will become impossible to manage over time.

Developers are inundated with the complexities associated with the new infrastructure-related concepts Kubernetes introduces. In addition to their application code and updates, developers must learn, create, and manage infrastructure-related objects.

This increases application delivery complexity, presents a steep learning curve, and takes focus away from delivering applications and updates fast.

The cloud-native space has evolved rapidly over the last few years. It's now time to bring an application layer level that can simplify pipelines and detach the application from the underlying infrastructure.

Benefits

Pipeline Structure

Ketch implements a standard application definition that can be used across tools such as Terraform, Pulumi, Crossplane, and others, enabling you to adopt multiple control planes or move between tools without creating pipeline complexity.

Developer Experience

Ketch allows developers to focus on the application code instead of the underlying infrastructure objects imposed by the different IaC tools, pipelines, or clusters.

Developers can have their applications easily deployed without learning, creating, and maintaining Kubernetes-related infrastructure objects, which can drastically accelerate Kubernetes adoption, reduce the learning curve, and accelerate the delivery of applications and updates, thus improving the developer experience.

Application Context

Ketch greatly simplifies application support and maintenance by allowing developers, DevOps, and Platform Engineering teams to operate applications from an application context view instead of an object-oriented context.