- Industry
- FinTech / FP&A
- Headquarters
- Tel Aviv, Israel
- Founded
- 2015
- Employees
- 400
- Technology Stack
- Azure, AKS, Kubernetes, GitOps, OpenTelemetry, groundcover eBPF
We stopped choosing what to observe based on the bill. Now we collect what we need, it is on every cluster, and it is all in Git.
Alex Elkind, Platform / DevOps Team, Datarails
Datarails replaced Datadog and fragmented monitoring tools with groundcover, gaining immediate eBPF visibility across its Kubernetes infrastructure while migrating to OpenTelemetry at its own pace. Today, 124 users across engineering and business teams rely on a shared observability platform, with dashboards, monitors, and alert routing managed entirely through Git.
About Datarails
Datarails is a financial planning and analysis (FP&A) platform that helps finance teams at small and midsize businesses automate reporting, budgeting, forecasting, and financial consolidation. By connecting to customers' ERP systems, CRMs, and spreadsheets, Datarails brings financial data together for reporting, planning, and AI-driven analysis.
Serving customers across North America, the UK, and Europe, Datarails operates a distributed cloud infrastructure on Microsoft Azure. Its environment includes approximately 15 Azure Kubernetes Service (AKS) environments spanning development, testing, demos, and production regions in the United States, Canada, the United Kingdom, and Sweden.
Behind the platform is a mix of Python/Django applications, FastAPI microservices, Node.js, .NET services, and data infrastructure including PostgreSQL, MongoDB Atlas, StarRocks, Redis, and RabbitMQ. The Platform/DevOps team manages this infrastructure through Terraform, Terragrunt, Helm, and ArgoCD.
With services distributed across multiple clusters and regions, the team needs to understand application behavior, database performance, and infrastructure health without relying on every development team to instrument its services correctly.
The Challenge: When Observability Costs Decide What You Can See
Before groundcover, Datarails used Datadog for application performance monitoring, database monitoring, logs, and metrics. Application tracing depended on Datadog libraries installed inside individual services, while separate agents collected metrics and logs. Some Kubernetes clusters also maintained their own Prometheus installations.
The arrangement worked, but it created two increasingly difficult problems: observability costs were growing faster than the team could comfortably predict, and coverage depended on how consistently individual services were instrumented.
Datadog costs were growing faster than usage and were hard to forecast. Custom metrics were particularly expensive, forcing the team to limit what it collected.
This affected engineering decisions directly. Business and application metrics that could have helped teams understand their systems were never created because the additional telemetry would increase costs.
The instrumentation model created a different problem. Services only had useful application traces if their teams installed and maintained the Datadog tracing libraries correctly. Some services appeared instrumented but produced no server spans at all.
The existing libraries also complicated the transition to OpenTelemetry. Datarails wanted to adopt open instrumentation standards, but conflicts between the Datadog libraries and OpenTelemetry meant the team could not simply migrate every service independently.
The team faced four recurring constraints:
- Cost limited coverage. Expensive custom metrics and unpredictable overages meant teams collected less telemetry than they needed.
- Tracing depended on application code. Services could appear instrumented while producing no useful spans.
- Vendor-specific libraries complicated migration. Existing Datadog instrumentation interfered with OpenTelemetry, making a gradual transition harder.
- Metrics collection was fragmented. Different agents, scrapers, and Prometheus installations required separate configuration and maintenance.
Datarails needed a different approach: complete baseline visibility without code changes, native OpenTelemetry support, predictable pricing, and an observability stack that could be deployed and managed like the rest of its infrastructure.
Why groundcover? Coverage First, Instrumentation on Their Terms
Datarails also evaluated other platforms, but found its setup and customization difficult, particularly alongside the OpenTelemetry migration already underway.
groundcover offered a closer fit with the team's Kubernetes, GitOps, and OpenTelemetry architecture.
1. Immediate visibility with eBPF, without changing application code
groundcover's eBPF sensor provided a baseline of traces, service maps, and HTTP and database visibility across Kubernetes workloads, including services that had never been instrumented.
Instead of waiting for each development team to install tracing libraries, the Platform/DevOps team could deploy the sensor and see services immediately.
groundcover let us see every service on every cluster from day one, without touching application code, and then let us finish the job with OpenTelemetry at our own pace.
This changed the starting point for observability. Every service received baseline visibility, while application teams could add richer OpenTelemetry instrumentation where needed.
2. OpenTelemetry without another vendor lock-in
Datarails wanted OpenTelemetry to become its application-level instrumentation standard.
groundcover's native OTLP ingestion allowed the team to send OpenTelemetry traces, metrics, and logs into the same platform as its eBPF telemetry.
That meant Datarails could migrate service by service rather than attempting a disruptive, all-at-once instrumentation change.
The team could also verify each migration in groundcover, comparing span volume, HTTP 5xx rates, and log-trace correlation before and after the transition.
3. One destination for metrics
Previously, Datarails maintained multiple metrics collection approaches, including separate agents and per-cluster Prometheus installations.
With groundcover, the team standardized on Prometheus Operator resources such as ServiceMonitor and PodMonitor, with an OpenTelemetry Collector forwarding metrics to groundcover.
Standard Helm charts could be integrated without vendor-specific configuration, and groundcover became the central metrics destination without requiring parallel self-hosted Prometheus stacks.
4. Observability managed through GitOps
Datarails already managed infrastructure through Terraform, Helm, and ArgoCD. It wanted observability to follow the same engineering practices.
groundcover's sensor was deployed through Helm and ArgoCD, while dashboards, monitors, integrations, and notification routes were managed in a dedicated Git repository.
A pull request shows the proposed changes, reviewers can inspect them, and merging deploys the configuration.
Observability changes became reviewable, repeatable, and available to engineering teams without requiring manual changes in the UI.
5. Pricing that doesn't discourage telemetry collection
The team wanted to stop treating every new custom metric as a potential budget problem.
With groundcover's pricing model, Datarails no longer needs to restrict custom metrics or telemetry volume simply to control the observability bill.
This allows engineering teams to collect the signals they need rather than designing monitoring around the cost of ingestion.
The Migration: Finding What Datadog Wasn't Showing
Datarails deployed groundcover through its existing Helm and ArgoCD workflow, starting in development, progressing through testing, and promoting to production region by region.
The first cluster was production-ready within a few weeks. According to the team, groundcover itself was straightforward to deploy. Most of the work involved tuning OpenTelemetry and integrating systems such as CloudAMQP, PostgreSQL, and MongoDB Atlas.
The eBPF sensor immediately exposed service maps and traces without requiring application changes.
But one of the most useful discoveries came during the OpenTelemetry migration.
Finding services that looked instrumented but weren't
Using groundcover logs and span counts, the team built a fleet-wide check to identify services that were not emitting server spans.
The results revealed services that appeared to have instrumentation but produced zero spans in production. In several cases, the existing vendor library was suppressing OpenTelemetry.
A single log query made it possible to detect these gaps across all 15 environments.
Most could be corrected through configuration changes, without modifying application code. The team then verified the fixes in groundcover within minutes.
In one production service, the results were measurable:
- Server spans increased from zero to approximately 60–75 per five minutes.
- Log lines containing a trace ID increased from zero to approximately 58 per ten minutes.
- The improvement required no application code change.
This gave the team a reliable way to migrate instrumentation incrementally while confirming that each service was actually producing useful telemetry.
Measure coverage, not features. Ask what you will see for a service nobody instrumented. That is where your next incident lives.
The Impact: Observability Becomes Shared Infrastructure
The change at Datarails went beyond replacing Datadog. Observability became a consistent part of the platform architecture, available across environments and managed through the same workflows as infrastructure.
Coverage across all 15 Kubernetes environments. groundcover's eBPF sensor provides baseline visibility across the fleet, with OpenTelemetry traces deployed for most services. New services and clusters receive coverage as soon as the sensor is running.
Datadog and fragmented monitoring tools consolidated. Datadog APM, separate metrics agents, and per-cluster Prometheus stacks were replaced by a unified observability platform.
Telemetry collection no longer constrained by custom metric pricing. Teams can add business and application metrics without making collection decisions based on the expected increase in their monitoring bill.
29 dashboards, 107 monitors, and 10 notification routes managed as code. Changes are reviewed through pull requests and deployed through Git, replacing manual configuration with a consistent engineering process.
124 active users across engineering and business teams. groundcover is used by R&D, Customer Success, Product, and other departments. Teams can create the views they need without waiting for DevOps to build every dashboard, while engineering teams take ownership of monitoring their own features.
AI agents can investigate production behavior directly. Datarails uses groundcover's MCP server to let coding agents query logs, traces, and metrics by enforcing the RBAC features and ensuring that no sensitive data is exposed. Engineers can check production behavior from their existing development workflows, while groundcover's SRE agent supports investigations.
Today, Datarails uses groundcover for Kubernetes and application monitoring, OpenTelemetry traces, logs and metrics, production health dashboards, alerting, and AI-assisted investigations.
The biggest organizational shift is that observability is no longer a collection of libraries and configurations maintained separately by individual teams. It is a shared platform capability.
Spotlight: Bringing Production Observability Into AI Workflows
Datarails is extending observability beyond traditional dashboards through groundcover's MCP server and AI SRE agent.
With MCP, engineers' coding agents can query production logs, traces, and metrics directly. Instead of asking another engineer to open a dashboard and investigate a service, an agent can retrieve the relevant telemetry as part of the development workflow.
Datarails also uses groundcover's own SRE agent to assist with investigations.
This is becoming an important part of how the team thinks about production monitoring. The goal is not simply to collect more signals, but to make those signals immediately useful to engineers and agents.
The next step is refining production alerts so they contain enough accurate context for an AI agent to begin investigating automatically.
What's Next: From Reactive to Proactive Monitoring
With the observability foundation established, Datarails is expanding what it monitors and how teams act on the data.
- Real User Monitoring. Add browser-side performance and error visibility to connect customer experience with backend behavior.
- Deeper database visibility. Bring more database logs into groundcover so database issues can be investigated alongside application traces.
- More business and application metrics. Add the custom metrics that were previously excluded because of cost.
- Complete the OpenTelemetry migration. Move the remaining services away from vendor-specific instrumentation.
- More proactive AI investigations. Refine production alerts so groundcover's SRE agent can begin investigating issues with the right context, ideally before customers report them.
For Datarails, the foundation is now in place: every new cluster can receive immediate coverage, application teams can instrument through open standards, and observability configuration follows the same GitOps processes as the rest of the infrastructure.
As Alex Elkind puts it:
We got full visibility on day one with eBPF, and moved to OpenTelemetry on our own schedule instead of a vendor's.




