450,000 Devices. One System. Real-Time. From physical tracker and cellular networks to real-time processing, time-series data, APIs, and operational services.
Gelios is a telematics platform that, as of August 2026, continuously processes data from approximately 450,000 tracking devices in active production. The platform maintains real-time position and status, reconstructs historical trajectories, and delivers live data to services in both commercial and public sectors.
Scalability is not about how many devices a system could theoretically handle. It is about how many it actually handles when everything must work reliably every single day.
Many systems are labeled with generic industry terms like "scalable", "high performance", "enterprise ready", or "mission critical". But real-world software engineering is not about marketing labels or synthetic benchmarks in sterile test environments.
Gelios does not need abstract claims. In August 2026, the platform continuously ingests, parses, validates, and stores telemetry from approximately 450,000 tracking devices in active production. This is not a benchmark, not theoretical capacity, and not a future roadmap. It is live production – and that is the definitive proof.
What does 450,000 active devices really mean?
A tracker is not a passive row in a database that updates once a month. It communicates constantly. Units move at highway speeds, jump between cellular towers, cross borders, lose signal in tunnels, buffer data packets locally, and reconnect in rapid burst transmissions.
Therefore, the platform cannot operate on the traditional web application lifecycle:
Instead, the infrastructure operates in a continuous, high-concurrency ingestion loop:
- → 450,000 physical devices emit continuous telemetry
- → Real-time ingestion, protocol parsing, and payload validation
- → Parallel updates: Current State + Time-Series History + Events
- → Instant delivery to external APIs, live map views, and enterprise services
A single dot on a map requires an entire ecosystem behind it.
What the end user sees in the interface may be a simple icon moving along a road. But before that dot is rendered, the data must traverse, validate, and compute across multiple specialized technological layers.
GPS & Vehicle Telemetry
Satellite fix (GPS/A-GPS), CAN bus metrics, ignition state, and inertial sensor telemetry.
Hardware & Cellular Net
Hardware firmware serializes telemetry packets and transmits over LTE-M/GSM via compact protocols.
Ingestion & Parsing
High-concurrency Go services and MQTT brokers ingest hundred-thousands of connections and parse payloads.
Real-time Processing
Jitter filtering, map matching, continuous mileage computation, and geofence boundary checks.
Instant State (Redis)
Last known coordinates, online status, velocity, and sensor state saved in sub-millisecond memory cache.
TimescaleDB Archives
Billions of telemetry points committed asynchronously to TimescaleDB for historical trajectory querying.
Business & REST API
Tenant authorization, fleet scoping, data normalization, and delivery via REST & webhook endpoints.
Live Map & Operations
The icon updates on screen – validated, geo-indexed, and integrated into customer workflows.
When this multi-tier pipeline executes continuously for ~450,000 active devices around the clock, architectural discipline, fault isolation, and efficiency become essential.
Real-time state and historical time-series are two distinct engineering challenges
A high-scale telematics engine must swiftly answer two fundamentally different queries:
Attempting to render live fleet views by querying historical telemetry tables would overwhelm any database architecture under 450,000 active device streams.
Therefore, instantaneous device state (Current State) is strictly decoupled from long-term time-series archives. This decoupling is a cornerstone that makes massive scale stable.
- • Senaste kända GPS-koordinat
- • Online / Offline heartbeat
- • Aktuell hastighet & riktning
- • Senaste sensortillstånd
- • Tidpunkt för senaste kontakt
- • Alla relevanta datapunkter
- • Historiska rörelsemönster
- • Rekonstruerade rutter & stopp
- • Körjournaler & rapporter
- • Tidsserier för sensorhistorik
Real-time for the present. Time-series for historical depth.
Gelios does not simply overwrite an asset’s latest coordinates. The engine continuously aggregates, verifies, and constructs comprehensive trajectory histories for hundreds of thousands of vehicles.
Trip & Stop Reconstruction
Algorithms stitch raw GPS telemetry points into smooth trips, filter stationary sensor drift, and compute precise departure, arrival, and idling durations.
Real-time Geofencing
Polygonal and radial geofences are computed on the fly to detect arrivals, departures, unauthorized night shifts, and automated job site billing.
Time-Series Telemetry
Speed profiles, fuel rates, engine hours, CAN bus diagnostic codes, and external temperature sensors stored in high-density time-series hypercubes.
A backend infrastructure that never sleeps
Traditional business systems or B2B SaaS web applications follow predictable human work patterns: high traffic during office hours, quiet evenings, and near-zero load during nights and weekends.
Gelios operates in the opposite paradigm. Hundreds of thousands of physical vehicles, heavy equipment, and telemetry units transmit continuously:
- ✓ In the middle of the night
- ✓ On weekends and holidays
- ✓ When no administrator is logged in
- ✓ When API clients are not actively polling
Not a single user needs to be logged in for the system to operate under full active load.
Standard Web App vs Real-Time Infrastructure
Long-term operational stability beats a synthetic benchmark
Real-time telemetry is only valuable when it keeps functioning flawlessly under relentless real-world load. The Gelios architecture is engineered to isolate faults and eliminate bottlenecks.
Specialized Microservices
High-concurrency Go and Node.js microservices dedicated solely to protocol decoding and telemetry ingestion.
High-Velocity Caching
High-frequency tracker requests and live states served directly from memory to prevent database thrashing.
State & History Isolation
Real-time fleet maps query lightweight state without getting stalled by heavy analytical reporting jobs.
Time-Series Hypercubes
Automated hypertable partitioning and data compression for billions of data points with indexed time windows.
Intelligent Batch Writes
Database writes are consolidated into micro-batches to maximize I/O throughput during sudden traffic spikes.
Asynchronous Queuing
Heavy analytical jobs, alert rule evaluation, and push dispatches run asynchronously without blocking ingestion.
Fault Isolation
An anomaly in a single device protocol or external webhook will never degrade core ingestion throughput.
Continuous Telemetry APM
Real-time telemetry monitoring packet latencies, queue depths, buffer limits, and node health.
Same product. Different technical challenges. Different tools.
Not all components of an enterprise platform have the same workload characteristics. Forcing high-frequency IoT traffic through standard web MVC frameworks inevitably creates severe bottlenecks.
Business logic, tenant permissions, user administration, and reporting thrive in robust application frameworks. In contrast, hundreds of thousands of high-frequency tracker requests require specialized services for:
- • Device configuration distribution
- • Telemetry ingestion & protocol decoding
- • Realtime tracker state tracking
- • Statistics & geospatial processing
- • High-frequency MQTT message collection
- • Ultra-low-latency cache-based request handling
Scaling is not just adding more servers. Sometimes the path through the system must be completely re-engineered.
A prime example is device configuration distribution. When hundreds of thousands of trackers regularly poll for updated parameters, traditional request cycles cause massive unnecessary CPU load.
The Technology Behind Real-Time Scale
Each component in the architecture is selected for specific concurrency, throughput, and reliability requirements.
Laravel / PHP
Robust enterprise application layer managing multi-tenancy, authentication, role policies, and REST APIs.
Go & Node.js
Ultra-high concurrency compiled ingestion microservices handling continuous packet deserialization.
MQTT / EMQX
Distributed high-throughput MQTT messaging broker purpose-built for low-overhead IoT telemetry.
TimescaleDB
PostgreSQL-native time-series database managing billions of data points with automated chunk compression.
PostgreSQL
ACID-compliant relational database for fleet registers, organization hierarchies, and business logic.
Redis / Memcached
In-memory key-value stores for instant tracker position state, geofence caching, and config lookups.
Architectural Data Flow
Infrastructure that external systems build upon
Gelios is not just a standalone user interface. The platform’s telemetry streams and APIs serve as the operational backbone for external commercial applications and public sector operations.
When external systems depend on continuous location data for day-to-day operations, system uptime, backward compatibility, and reliable API interfaces become paramount.
Wide Range of Applications
- ✓ Commercial fleet management and transport logistics
- ✓ Public sector services and municipal vehicle coordination
- ✓ Construction machinery, field service vans, and asset security
- ✓ Third-party dispatch APIs and custom enterprise dashboards
The system begins in the physical world.
The hardware tracker collects ground truth from the vehicle and its environment, initiating an unbroken chain that ends in an API, a live map, or an enterprise workflow.
Engineering insights that cannot be learned from a tutorial
The definitive value we bring to our clients is real-world experience operating platforms of this magnitude. It yields actionable insights that only emerge under high-concurrency production:
Where real bottlenecks appear
Identifying hidden locking and I/O saturation before it causes production latency.
How data must be partitioned
Partitioning time-series chunks so analytics never block live state ingestion.
When caching actually works
Designing cache invalidation without causing cache stampedes under high concurrency.
When to split the monolith
Pragmatically extracting only high-frequency bottlenecks into dedicated microservices.
Asynchronous execution
How background queues and micro-batches smooth out resource spikes effortlessly.
Architecture evolution in live ops
Migrating systems and upgrading protocols without a single second of production downtime.
Reuse the standard. Custom-engineer what is truly hard.
The specialized Gelios real-time ingestion stack is distinct from the Alegor platform core. This is a critical architectural distinction.
Alegor is leveraged for universal application requirements: user management, tenant hierarchy, role permissions, audit logging, and core API structures. The specialized Gelios stack solves domain-specific engineering: high-throughput telemetry ingestion, binary tracker protocols, real-time state, and geospatial time-series data.
Alegor does not replace advanced engineering—it frees our team to focus engineering effort where it matters most.
Clear Separation of Concerns
active tracking devices in continuous live production
Continuous high-throughput telemetry ingestion and state processing 24/7/365.
Trajectories, trips, and diagnostics archived into compressed time-series hypercubes.
Telemetry and APIs power daily operations for enterprise and public sector organizations.
“The definitive test of a real-time platform is not how it behaves with a hundred units in a sandbox. It is whether it continues to run flawlessly when hundreds of thousands of physical devices transmit data every single day.”
Concrete Facts from Live Production
No buzzwords – pure engineering outcomes and verified production stability.
Devices in Production
The platform continuously ingests and processes data from ~450,000 physical trackers in live operation (August 2026).
Decoupled Pipelines
Delivers sub-millisecond current state queries while managing deep historical trajectory data.
Uninterrupted Uptime
Engineered for continuous telemetry intake, even when zero human users are logged in.
External Integrations
Gelios serves validated telemetry feeds to mission-critical commercial and public sector platforms.
Architecture Scaled with Load
Specialized Go services, Redis in-memory caching, and TimescaleDB hypercubes were introduced incrementally where live production demanded optimization.
Does your platform need to perform when scale gets serious?
Building the prototype is straightforward. The real engineering begins when data volume, throughput, and dependencies surge. We design and scale business-critical systems built for real-world production.