Platform architecture

The HexitHive control plane, player layer and APIs in one view.

HexitHive is a classic control-plane/data-plane design: a multi-tenant portal for humans, an API surface for devices, and lightweight Raspberry Pi players that cache content locally and report back via heartbeats.

Layers of the platform

You can think of HexitHive as three main layers: the control plane (Portal), the device layer (Players) and the API / sync layer that connects them.

Control plane: HexitHive Portal

The Portal is a multi-tenant web application where you create tenants, users, screens and playlists. It enforces permissions, stores configuration in a central database and exposes the API endpoints that players use to register, fetch content and send heartbeats.

Device layer: HexitHive Players

Each HexitHive Player is a Raspberry Pi-based device on site. It connects over the internet (or private WAN) to the Portal, synchronises its assigned playlist and media, and then plays everything locally via HDMI to your screens.

API & sync layer

The Portal exposes a small, focused JSON API that devices call to register, fetch configuration, send heartbeats and log events. The API is designed to be idempotent and resilient so players can safely retry during network jitter without breaking state.

Multi-tenant structure

HexitHive is built to serve many customers and organisations from one installation, while keeping configuration and access strictly separated.

Tenants, companies & screens

Tenants represent customers or large internal groups. Inside each tenant you manage companies, branches or sites, with one or more screens per location. A screen maps 1:1 to a physical player device.

Playlists & media assets

Content is broken into media assets (images, MP4s, layouts) and assigned to playlists. A playlist is then attached to one or more screens. When you update a playlist in the Portal, affected players pick up the new config on their next sync.

Roles & delegated control

Role-based access control lets global operators manage many tenants, while each tenant’s admins can manage only their own screens and content. Operators never see configuration outside of the tenants they’re allowed to touch.

Player lifecycle & sync

Players are designed to be predictable: pair once, sync regularly, play from local cache and keep telling the Portal how they’re doing.

1. Pairing & identity

When a new Player boots, it generates a hardware identity and pairing PIN. You enter that PIN into the Portal, link it to a tenant and a screen, and the Portal issues a device key. From that point on, the Player authenticates using that key instead of the one-time PIN.

2. Fetching configuration

The Player periodically calls the Portal to fetch its configuration: which screen it belongs to, which playlist is active, and which media assets are required. The Portal responds with a compact JSON document that describes the desired state for that device.

3. Downloading & caching media

Based on the configuration, the Player downloads any missing media files into a local content directory. Once cached, playback is entirely local – the device doesn’t need a permanent internet connection to keep running the existing playlist.

4. Playback & monitoring

While the playlist is running, the Player sends regular heartbeats back to the Portal with status information (up, down, last sync, last content update). It can also log events such as media errors or configuration changes to feed into monitoring and dashboards.

API surface

The Portal exposes a compact HTTPS JSON API that devices use. It’s deliberately narrow, so it’s easy to reason about and secure.

Device registration

Endpoints handle the initial registration and pairing of players, validate the pairing PIN, and issue long-lived device keys. These keys are scoped to a specific screen and tenant and can be revoked if needed.

Configuration & playlist fetch

Players call configuration endpoints to retrieve their current desired state: assigned playlists, media manifests and runtime options. Responses are idempotent, so players can poll on a schedule or on-demand without causing side effects.

Heartbeats & events

Heartbeat endpoints record that a device is alive, plus simple health signals. Event endpoints can optionally log warnings, playback errors or other telemetry that can later be surfaced as dashboards or alerts.

Security & resilience principles

HexitHive is built with a few boring-but-important principles: tenancy isolation, least-privilege access, and assuming that networks will be flaky.

Tenant isolation

Every configuration object – screens, playlists, media and users – belongs to a tenant. Portal views and API calls are always made in the context of a specific tenant, which prevents accidental cross-customer access.

Role-based access

Authentication is layered with roles so that operators have exactly the rights they need and no more, whether they’re managing one tenant or many. Tenants can be delegated access without exposing internal MSP tooling.

Offline-first playback

Because players cache all required media locally, the worst-case scenario for a WAN outage is “the screen keeps looping yesterday’s playlist”. Heartbeats and monitoring highlight link or sync issues, but the viewer experience stays smooth.

Where this fits into your stack

Most teams drop HexitHive alongside their existing monitoring, logging and ITSM tooling – not instead of it.

Monitoring & NOC tools

Heartbeats and events can be surfaced via dashboards, or integrated with your existing NOC tooling to raise alerts when screens go offline or fail to sync new content.

Change & governance

Because the Portal is the single source of truth for player config, you can treat playlist and layout changes the same way you treat infrastructure changes: plan, review, approve, then publish.

From architecture to pilot

If t