From Raw Platform Telemetry to Accurate, Bill-Ready Usage — Without Building a Custom Mediation Stack
Case Study · Cloud & Infrastructure
From Raw Platform Telemetry to Accurate, Bill-Ready Usage — Without Building a Custom Mediation Stack
Industry
Cloud & Infrastructure
Size
~500 employees
Region
Europe
Monetization Model
Consumption-Based
About Customer
Use case
Consumption Billing Automation & Revenue Accuracy
Transformation
Homegrown Mediation Risk → UsageCloud + BillingPlatform Stack
Company
A European cloud application platform running consumption-based pricing across the full range of platform activity — network requests, bandwidth, content optimisation, security services, and build compute (CPU and memory). Operating as a usage-based infrastructure and SaaS provider, the company’s entire revenue model depends on accurately capturing, metering, and billing high-volume platform consumption across a heterogeneous landscape of event sources. Getting that right at scale, without building and maintaining a custom mediation stack, was the central infrastructure challenge.
Situation
The company needed to turn raw platform consumption into accurate, billable usage — without pushing the complexity of telemetry handling into the billing system and without committing engineering resources to building and maintaining a homegrown mediation layer indefinitely. The usage signal was high-volume and fragmented across multiple source types: real-time APIs and streams, periodic batch files, and operational systems — many of which had no outbound APIs and could never deliver clean usage data to any billing provider on their own. Each source type required a different ingestion approach, and the billing system needed to receive only clean, deduplicated, bill-ready records — never raw event floods.
Challenges
- High-volume, fragmented consumption signals across incompatible source types — real-time APIs, batch files, and legacy operational systems with no outbound interfaces — each requiring a different ingestion approach with no unified collection layer.
- Non-billable usage — trial projects and records without a billing profile — had to be filtered before reaching the billing system, requiring in-pipeline gating logic that no standard billing tool could apply at the mediation layer.
- Billing system architecture required clean, sequenced, deduplicated records — raw event floods would have overloaded BillingPlatform’s ingestion path and pushed telemetry complexity into a system not designed to handle it.
- Building and maintaining a homegrown mediation layer would permanently redirect engineering capacity away from the product roadmap — an ongoing cost with no ceiling.
Why DigitalRoute
Homegrown mediation replaced with a purpose-built collection and metering layer feeding BillingPlatform
The problem was not billing — it was everything that had to happen before billing. BillingPlatform was the right system for rating, invoicing, and revenue recognition. But it needed to receive clean, validated, bill-ready records, not raw platform telemetry. UsageCloud™ was built to solve exactly that gap: collecting usage from any source, mediating it to finance-grade quality, and delivering it in the format downstream systems expect.
- Reaches every source, regardless of interface. UsageCloud ingests across API, streaming, batch, and legacy sources — including operational systems with no outbound APIs, retrieving the signal directly. Every cons
- Clean system ownership, by design. UsageCloud™ carries usage and only usage. Customer and contract master data flows to BillingPlatform through its native CRM connector. Each platform is the system of record for exactly what it was built to own — no overlap, no coupling, no fragility at the boundary.
- Configuration, not code. The usage pipeline is configured, not built. Engineering stays on the product roadmap; the mediation layer does not create an ongoing maintenance obligation. Pricing model changes are made through configuration in the mediation layer — BillingPlatform continues to execute billing without a rebuild per change.
The Solution
Mediation and metering layer between fragmented platform sources and downstream billing
UsageCloud™ was deployed as the mediation and metering layer between the platform’s consumption sources and the downstream billing system. Raw events — infrastructure activity, API calls, compute, storage, and network — are ingested across every source type, including operational systems with no outbound interfaces that are accessed by pulling the signal directly.
Inside the pipeline, UsageCloud™ validates, deduplicates, corrects, and enriches events in-stream. Non-billable usage — trial projects and records without a billing profile — is filtered before it ever reaches billing. Clean events are metered with customer and product context and sequenced into bill-ready, record-level usage. A separate analytics stream runs in parallel, tracking rolling consumption trends for the business — entirely distinct from what billing receives.
Batched, deduplicated records are delivered to BillingPlatform in the format it expects, where rating, invoicing, collections, and revenue recognition are applied. The integration pattern proved in this deployment became the blueprint for the BillingPlatform Connector now shipping in UsageCloud™.
The Outcome
Zero
Revenue leakage
No billable consumption lost, duplicated, or misclassified. Targeted reprocessing and a full record copy keep every invoice defensible.
Pricing agility
Without re-plumbing
Pricing models change through configuration — no rebuild of billing infrastructure required.
Configured
Not coded
Engineering stays on the product roadmap — the usage pipeline is configured, not coded.
Scalable
Foundation
New metrics, product lines, and services onboard through the same layer — no downstream rework per source.
The Architecture
Facing a similar challenge?
Talk to us for a walkthrough of how this transformation was done and what it could look like for your business.