Cresta reduces observability costs by 80% by migrating to groundcover

In a nutshell:

1. Annual observability costs were reduced by 80% compared to their previous setup.
2. Faster debugging and more reliable incident resolution.
3. Engineers empowered to craft custom queries
4. Cresta gains a robust foundation for scale, evolving Kubernetes workloads, and complex use cases.

About Cresta

Cresta, a leading contact center AI platform for human and AI agents, operates in a technical landscape built and run on Kubernetes, hosted on AWS Elastic Kubernetes Service (EKS). Their architecture combines cutting-edge machine learning models with a highly scalable compute environment, including EC2 instances and Lambda functions. With a strong engineering culture and a need for deep technical insight, Cresta needed a solution that aligns perfectly with their Kubernetes-first philosophy.

The Problem: Observability in a Kubernetes-first world

For years, Cresta relied on a SaaS solution to meet their observability needs. The vendor's user-friendly UI and comprehensive feature set made it a strong choice, but its pricing model became a critical hindrance on Cresta’s dynamic Kubernetes environment. The vendor’s billing repeatedly penalized Cresta and compromised its ability to grow by applying:

• Aggressive spot instance usage: Nodes frequently cycled in and out, leading to inflated charges.
• Horizontal autoscaling: Nodes spinning up to meet peak demand resulted in disproportionately higher costs.

"groundcover’s monthly average node-based pricing model completely removed the anxiety that came with scaling our environment”

- Michael Parker, Software Engineer, Cresta

‍When Cresta began evaluating alternatives, they experimented with open-source solutions. While attractive in theory, the reality was far more challenging:

• Deployment complexity: Documentation lagged behind frequent product updates, making it difficult to set up a stable, functional stack.
• Maintenance overhead: Distributed system components (Prometheus, Loki, Tempo) required constant management and optimization.
• Lack of unified view: Disparate tools in the OS stack struggled to provide the seamless, contextual insights Cresta engineers needed.

These challenges drove Cresta to search for a Kubernetes-native solution that could provide granular observability without the operational and financial drawbacks of their existing stack.

The Solution

‍Cresta discovered groundcover and immediately recognized its potential to address their observability pain points. groundcover’s Kubernetes-first design and eBPF-based approach brought a technical depth and flexibility that resonated with Cresta’s engineering ethos.‍

Why groundcover?

• Kubernetes-native observability: groundcover integrates directly into Kubernetes at the workload level. Using eBPF, groundcover captures low-level system events and traces with minimal performance overhead. This allows Cresta to monitor:
  • Pod-level CPU and memory usage.
  • Kubernetes scheduling and resource allocations.
  • Cross-service communication patterns.
• Network and system insights: groundcover’s eBPF sensor enables Cresta to monitor traffic patterns and API interactions at the network layer. For example:
  • During a recent red-team exercise, DNS traces revealed attempted data exfiltration.
  • Traces of third-party API calls exposed payload mismatches, helping the team to achieve faster debugging and resolution.
• ClickHouse-powered data flexibility
  groundcover’s backend includes a ClickHouse instance being deployed in your environment, to store your logs, traces, and Kubernetes events. As Cresta’s engineers were very familiar with ClickHouse, having used their storage solution for other needs, it provided them unparalleled querying flexibility, including the ability to:
  • Run custom SQL queries for root-cause analysis.
  • Combine log, trace, and metric data into unified visualizations.
  • Query Kubernetes events in ways their earlier solution couldn’t support.

Cost efficiency at scale

groundcover’s pricing model, which is based on an average node usage at the monthly level, aligned perfectly with Cresta’s scaling strategy. Unlike their previous observability solution, it did not penalize Cresta for spinning up nodes temporarily to handle workloads. This resulted in a 80% reduction in observability costs without sacrificing coverage.

״There’s been a number of times where an engineer says, ‘Man, I wish we had logging for this,’ and I’m like, ‘Hey, have you looked at these traces?’ They found exactly what they were looking for without having to add sample logs to the code. That’s when we knew we’d made the right decision."

- Michael Parker, Software Engineer, Cresta

The Impact

1. ‍Enhanced observability depth: Cresta engineers gained unprecedented visibility into their Kubernetes environment. With groundcover, they can:
   • Query high-cardinality metrics without performance concerns.
   • Use eBPF traces to debug network issues without adding application-level logging
   • Monitor Kubernetes events directly, a previously complex task for them.
2. Third-party API debugging made simple: One of the most valuable outcomes was the ability to debug third-party API interactions effortlessly. groundcover’s traces captured request and response payloads at the network layer, enabling engineers to:
   • Identify and document API contract violations.
   • Create alerts for recurring issues in payloads.
   • Reduce time-to-resolution for integration-related bugs.
3. Alerts and visualizations for enhanced proactivity: Cresta engineers quickly leveraged groundcover’s Explore and Monitors features to:
   • Build actionable visualizations on high-impact metrics.
   • Setup alerts on key traces and events to identify production issues in real time.
4. Reduced maintenance overhead: Unlike open-source alternatives, groundcover’s inCloud Managed setup requires no dedicated team to deploy and manage its infrastructure. It ensured:
   • No-touch, consistent updates and configurations.
   • Minimal operational overhead, allowing engineers to focus on core product development.

"The installation process was very easy. groundcover’s Helm chart just worked, and the platform was ready to provide value right away. We did end up building our own OTel logging pipeline to make the setup more production-ready, reducing our metric cardinality by performing aggregation on our custom metrics. The groundcover team was particularly helpful during this process.״

- Michael Parker, Software Engineer, Cresta

Cresta’s adoption of groundcover showcases how Kubernetes-native observability can redefine monitoring for modern cloud-native environments. By combining technical depth, cost efficiency, and seamless usability, groundcover has become an indispensable part of Cresta’s infrastructure strategy, empowering them to innovate faster, debug smarter, and scale efficiently.