The Problem

Organizations that need private 5G/LTE connectivity face a choice between expensive carrier contracts or building fragmented infrastructure from scratch. This repo attempts to consolidate the full stack—core network integration, subscriber management, charging, and developer APIs—into a single deployable platform with data sovereignty baked in.

What This Does

The repo is a collection of four self-contained projects rather than one unified codebase:

  • apps/api-server — Go-based BSS (Business Support System) handling authentication, subscriber CRUD, automation, and billing. Entry point is cmd/server.go.
  • apps/carrier-connector — Go service for eSIM profile management via GSMA ES2+ interfaces. Entry point is main.go.
  • apps/charging-engine — Rust-based real-time credit control and usage tracking.
  • apps/packet-gateway — Rust service using eBPF for packet processing and QoS enforcement.

The sdk/ directory contains client libraries for Go, Python, TypeScript, Kotlin, Ruby, Swift, and Rust. deployments/ holds Kubernetes manifests and Docker Compose files.

How It Is Wired

Execution starts at main in apps/api-server/cmd/server.go:35, which reaches 399 functions. The call graph shows 3,314 resolved internal edges. The most-connected functions are Where (called from 159 places), WithError (125), and Info (84)—these carry the widest blast radius if changed.

The shortest path from entry to external effect: main -> NewDatabase reaches the filesystem via gorm.Open. Run in internal/websocket/handler.go:55 reaches the database via c.repo.Create and the network via s.client.Post in two hops.

Key responsibility map:

  • internal/logging/logging.go — logging config, called from 65 files.
  • internal/database/crud.go — subscriber CRUD, makes outbound network calls.
  • internal/cache/cache.go — memory cache with expiration, 45 callers.
  • internal/handlers/platform_automation.go — automation CRUD, touches DB and network.
  • sdk/typescript/src/types — hub module with 12 dependents; churn here is high-blast-radius.

The module graph shows no circular dependencies across 93 modules and 81 edges—clean layering.

How To Use It

The repo provides a Makefile and Docker support. The README documents Traefik as the API gateway with unified HTTPS access via https://api.telecom.com. Exact build commands are not fully documented in the README excerpt; the Makefile likely contains targets.

Configuration lives in apps/api-server/.env.example and apps/charging-engine/.env.example. The API server runs via apps/api-server/cmd/server.go.

Real-World Use

An eSIM operator (Airalo-style) would deploy this to aggregate multiple carriers, provision eSIMs via the carrier connector, bill through the charging engine, and expose subscriber management via the REST API. The CLI in apps/cli provides operational control for service orchestration and health checks.

Code Health & Issues

Static analysis found 51 findings: 2 high, 49 medium, 0 low.

  • High — Deep nesting (x28) — apps/packet-gateway/src/main.rs, apps/api-server/docs/docs.go, apps/api-server/internal/services/charging.go have max indentation depth of 10. Fix: early returns and guard clauses.
  • High — Duplicated code blocks — 436 repeated 6-line blocks across 142 files, including apps/api-server/cmd/server_deps.go and internal/handlers/integration_test.go. Fix: extract shared helpers.
  • Medium — Hub module — sdk/typescript/src/types.ts has 12 dependents; high-blast-radius for changes.
  • Medium — Oversized file — apps/api-server/docs/docs.go at 770 lines.
  • Medium — High branching density (x20) — internal/database/crud.go has 45 branch points over 160 lines.

The code health audit flags committed secrets in deployments/kubernetes/manifests/secrets.yaml, unpinned GitHub Actions (use commit SHAs, not @v4), missing lockfile for Cargo.toml, privileged Docker mode with host networking, and continue-on-error on a correctness step in CI. Also missing: Dependabot, least-privilege token permissions, and repo convention files (.editorconfig, .gitattributes).

The Bottom Line

This is an ambitious portfolio covering the full private cellular stack with clean module layering and multi-language SDKs. The code quality issues—deep nesting, duplication, and CI gaps—are real but fixable. It is not production-ready as-is; treat it as a strong reference architecture for evaluating private 5G/LTE platform design rather than a drop-in deployment.