Menu
Dev.to #systemdesign·July 28, 2026

Building a High-Concurrency Edge-First Accreditation System

This article outlines an architectural approach for high-concurrency physical access control systems, such as those found at large events. It emphasizes an edge-first validation architecture to ensure low-latency access, decoupling hardware control from cloud-based analytics. The design leverages local caching and asynchronous telemetry streaming to maintain responsiveness even during network outages, providing both security and valuable business insights through data analytics.

Read original on Dev.to #systemdesign

The Challenge of High-Concurrency Physical Access

Traditional centralized architectures struggle with the demands of physical access control at large-scale events, where thousands of users may attempt to cross sensor thresholds simultaneously. Relying on standard REST API calls to a cloud database can lead to catastrophic network saturation and unacceptable latency, preventing gates from opening promptly. This necessitates a resilient, real-time telemetry pipeline that prioritizes local validation.

Edge-First Validation Architecture

To achieve sub-20 millisecond gate opening times, the system employs an edge-first validation architecture. All Role-Based Access Control (RBAC) logic resides on local edge nodes within the venue's intranet. This setup ensures that access decisions, like validating an RFID or mobile pass against clearance levels, occur without any external WAN calls.

javascript
const Redis = require('ioredis');
const localCache = new Redis({ host: '10.0.0.5', port: 6379 });

async function processPhysicalAccess(credentialPayload, gateId) {
  const { hexUid, timestamp } = credentialPayload;
  const delegate = await localCache.hgetall(`credential:${hexUid}`);
  const gateRules = await localCache.hgetall(`gate:${gateId}`);

  if (delegate && Number(delegate.clearanceLevel) >= Number(gateRules.requiredClearance)) {
    hardwareController.openGate(gateId);
    await localCache.rpush('telemetry_sync_buffer', JSON.stringify({ uid: hexUid, zone: gateRules.zoneId, action: 'ENTRY', ts: timestamp || Date.now() }));
  }
}

Decoupling Hardware Validation from Cloud Analytics

A crucial design decision is the complete isolation of the hardware validation loop from the cloud sync worker. After local validation and gate opening, spatial event data is buffered locally (e.g., using Redis `rpush`). A separate, asynchronous worker then continuously drains this `telemetry_sync_buffer` and pushes batched payloads to the centralized cloud via WebSockets. This architectural pattern ensures that even if the venue's external Wi-Fi drops, physical gates continue to function without interruption. Once connectivity is restored, the buffered telemetry seamlessly synchronizes, updating real-time dashboards.

💡

Architectural Benefits

This decoupled, edge-first approach offers significant benefits: - High Availability: Gate access is not dependent on external network connectivity. - Low Latency: Validation occurs locally, ensuring rapid response times. - Scalability: Edge nodes handle immediate processing, offloading the central system. - Resilience: Temporary network outages do not impact core functionality.

edge computingreal-time systemshigh concurrencyevent processingaccess controloffline capabilitiesdata bufferingsystem resilience

Comments

Loading comments...