Case Study: How We Built an Enterprise Telecom Billing Platform in Laravel (CDR/SDR, Bundles, Invoicing)

When telecom billing breaks, it’s not just a technical issue—it’s revenue leakage, customer disputes, and operational chaos. This case study shows how our team built a billing platform for a UK telecom provider designed to ingest high-volume CDR/SDR files, apply complex rating and bundles, and generate invoices reliably—at scale.

Stack: Laravel + MySQL + Redis + Horizon + Queue-based processing + event-driven workflows.

Related: our telecom billing and revenue-assurance platform case study.

---

Executive Summary

Client profile: Telecom / VoIP / managed connectivity provider (multi-customer billing, complex tariffs, bundles, and contract billing).

• Core problem: Billing accuracy, performance bottlenecks, and exception handling across CDR/SDR imports and rating workflows.
• Solution: A Laravel-based billing platform with chunked imports, deterministic normalization, scalable queue-based rating, bundle application, and automated invoice generation.
• Outcome: A reliable billing pipeline that scales with volume and supports enterprise operations with auditability and exception workflows.

---

The Challenge

Telecom billing is uniquely hard because it combines high-volume event ingestion with complex business logic:

• CDR/SDR files can be very large and arrive frequently.
• Data quality varies by supplier: inconsistent date formats, scientific notation, partial numbers, inconsistent charge codes.
• Rating logic depends on multiple dimensions: charge codes, prefixes, time spans, rounding rules, connect fees, minimum charges, discounts, and custom overrides.
• Bundles add another layer: included/excluded dial codes and charge codes, remaining allowances, and re-rating when plans change.
• Operations need a clear exception workflow: what failed, why it failed, who owns it, and what to do next.

The real requirement wasn’t “import a CSV.” It was to build a system that could produce auditable billing outcomes and remain stable as data and rules evolve.

---

Our Solution: Billing Platform Architecture

We designed a billing pipeline that separates responsibilities cleanly and scales via queues:

Upload Usage File
  → Validate + store
  → Import (chunked)
  → Normalize keys + dedupe
  → Rating (queue-based rerating)
  → Bundle application (voice/SMS/data/MMS)
  → Summary + unbilled charges
  → Invoice generation + audit logs

1) Import at Scale (Chunking + Safe Write Modes)

We built import jobs that stream CSV data and process it in chunks. This avoids memory spikes and makes the system stable across different server sizes.

• Chunked processing (e.g., 1,000–5,000 rows per batch)
• Write modes for safe operations:
  • Patch: upsert based on a natural key
  • Replace: delete matching key-tuples then insert fresh rows safely
• Validation + issue logging instead of failing the whole import

2) Dedupe & Normalization (Enterprise Data Hygiene)

We implemented deterministic normalization rules for date/time formats and phone fields, and added a deduplication key so reruns don’t create duplicates.

// Example dedupe key idea (conceptual):
md5(billing_id|cdr_date|cdr_time|cdr_type|source|destination)

This dramatically reduces reprocessing risk and helps support teams trust the data.

3) Queue-Based Rating Engine (Tariffs, Time Spans, Overrides)

The rating engine runs as queue jobs so it scales horizontally. It supports both “cost from tariff” logic and legacy rules, including:

• Charge code matching + longest-prefix matching
• Peak/off-peak/weekend time span rules
• Unit conversion and billing unit validation
• Precision handling and rounding rules
• Connect fees, minimum charges, discounts, post-call surcharges
• Structured issue creation (missing tariff, currency mismatch, mapping issues)

Why this matters: enterprises need deterministic calculations and traceability—especially when customers dispute invoices.

4) Bundle Application (Voice/SMS/Data/MMS) with Accurate Allowance Tracking

Bundles were implemented as a dedicated queue stage, applying allowances per billing_id and sorting events by start time. The engine supports:

• Bundle eligibility rules (included/excluded dial codes and charge codes)
• Longest-prefix dial matching for accurate allowance application
• Per-type limits (minutes/SMS/MMS, data in MB)
• Atomic allowance updates to avoid race conditions
• Reprocessing behavior (mark previous applications rejected and recalculate)

This stage ensures the final end-user price reflects bundled usage accurately.

5) Exception Workflow (The “Ops Backbone”)

Instead of dumping failures into logs, the platform records structured issues with categories (e.g., missing tariff rates, orphan billing IDs, mapping issues, duplicates). This makes exceptions:

• Searchable (by supplier, billing period, category)
• Assignable (team workflows)
• Exportable (for supplier disputes or internal reviews)
• Auditable (who ignored/resolved what, and why)

6) Invoice Generation + Unbilled Charges

After rating and bundles, the system generates usage summaries and writes unbilled charges (daily/monthly). Invoice generation is handled via a dedicated job that calculates outstanding balances, usage charges, VAT/tax, and produces invoice items with a traceable breakdown.

---

Operational Scaling: Horizon Queues & Server Profiles

Billing workloads aren’t uniform—imports, rating, bundles, and exports have different CPU/memory characteristics. We configured dedicated queues (and Horizon supervisors) so each workload scales independently.

• imports: file ingest + chunk parsing
• rating: CPU-heavy cost calculations
• bundles: sequential allowance application with locks
• default/notifications: webhooks, emails, small tasks

Result: predictable throughput on different server sizes—from small nodes to high-memory machines—without random “queue interference.”

---

What Made This Project Successful

• Deterministic pipelines: each stage has clear inputs/outputs.
• Idempotency + dedupe: safe reruns, safe retries.
• Structured exceptions: operations can act without engineering bottlenecks.
• Queue-first design: scale horizontally when volume increases.
• Auditability: the system can explain “why this invoice total is this number.”

---

How We Can Help You

If you’re building (or fixing) an enterprise billing system, the architecture decisions matter more than the UI. We help teams design scalable Laravel systems with reliable queue pipelines, data validation, and auditability.

---

FAQ

What makes telecom billing projects fail?

Most failures come from weak data normalization, lack of idempotency, unbounded ORM queries, and no operational exception workflow. Enterprises need predictable pipelines and traceability.

Can Laravel handle high-volume billing workloads?

Yes—when designed correctly: chunked imports, queue-based rating, workload-separated Horizon queues, and database indexes built around real query patterns.

How do you handle reprocessing and rerating safely?

By designing idempotent jobs, using dedupe keys or natural keys, storing processing history, and ensuring reruns either patch safely or replace atomically for matching key-tuples.