Managed displays for technical teams

Your screens, remotely managed.

DisplayOps turns a Raspberry Pi into a managed display for websites, dashboards, kiosks, and always-on screens. No Linux, no kiosk flags, no SSH. Flash it, pair it, tell it what to show.

  • Under 10 minutes to a live screen
  • Flat plans, not per-screen pricing
  • Your own Pi 4 or Pi 5
lobby-tv Raspberry Pi 5
Online
https://grafana.internal/d/ops?kiosk
99.98%412 rps24 ms
CPU temp
51.2 °C
Wi-Fi
-58 dBm
Storage
6.1 / 29 GB
Uptime
41 d 3 h
Browser
Healthy
Agent
v0.4.2
RefreshScreenshotRestart playerReboot
Flash. Pair. Display.

From blank Pi to live screen in three steps

If a technical user needs documentation to keep a URL on a screen, the setup is too complicated. So we removed the setup.

  1. 1

    Flash

    Write the DisplayOps image to a microSD card. It boots straight into the player. Nothing to configure.

  2. 2

    Pair

    The screen shows a short code and a QR code. Enter it in the portal, name the screen, done.

  3. 3

    Display

    Pick a website, dashboard, image, video, slideshow, or message. The screen updates immediately.

Built for dashboards, not ad campaigns

Tell a screen what to show. That is the whole job.

Opening and keeping a URL alive is the first-class workflow, not a content type bolted onto a signage editor.

Website or dashboard

Any URL. Grafana, Home Assistant, status pages, internal tools. Refresh intervals and rotation included.

Image

Menus, notices, welcome screens. Upload once, show on any screen.

Video

Looping video, cached on the device so it keeps playing offline.

Slideshow

Rotate several URLs or images with a per-item duration.

Message

Large text with your colours. Useful for emergencies and overrides.

Schedule

Start and end times, days of the week, screen-on hours.

Deep device operations

The screen is the product. So we manage the screen.

Cheap hardware only works at scale when problems are diagnosable from a browser. Every display reports its health, and every fix is one click or one API call.

See the device, not just the content

CPU temperature, storage, memory, Wi-Fi signal, HDMI state, browser health, agent version, uptime, and a live screenshot for every screen.

Fix it from your desk

Refresh the page, restart the player, reboot the device, or capture a screenshot. Every action is logged with who did it and when.

Recover without a human

A watchdog restarts a hung browser. Content is cached locally. A device that loses power boots straight back into service and converges to its desired state.

Automate it

Every action in the portal is available in the API. Webhooks fire on online, offline, and health events so your own systems can react.

# Point a screen at a dashboard
$ curl -X POST $API/displays/dsp_8k2m/content \
    -H "Authorization: Bearer $KEY" \
    -d '{"type":"website",
         "url":"https://grafana.internal/d/ops"}'

{ "ok": true, "state": "converging" }

# Ask how it is doing
$ curl $API/displays/dsp_8k2m
{
  "name": "lobby-tv",
  "online": true,
  "agent_version": "0.4.2",
  "telemetry": {
    "cpu_temp_c": 51.2,
    "wifi_rssi_dbm": -58,
    "disk_used_gb": 6.1,
    "uptime_s": 3553200
  },
  "player": { "state": "healthy" }
}
Why not a signage CMS?

Three ways to put a dashboard on a wall

DIY Raspberry Pi kioskDigital signage platformDisplayOps
SetupScripts, Chromium flags, autostart filesTemplates, campaigns, playlists to learnFlash, pair, paste a URL
Change the URLSSH or a keyboardEdit a playlist itemPortal or one API call
Browser crashesSomeone notices eventuallyVaries by playerWatchdog restarts it, you get an event
Device healthWhatever you scriptOnline / offlineCPU, storage, Wi-Fi, HDMI, browser, logs
PricingYour weekends$8 to $30 per screen per monthFlat plans from $0 for 3 screens
HardwareAnything, unsupportedOften a proprietary playerYour Pi 4 / Pi 5, tested image

Full comparison

Transparent fleet pricing

Flat plans. Small fleets stay cheap and predictable.

Website displays cost almost nothing to run, so we do not charge as if they did.

Personal

$0/mo

3 displays

Homelab, one office dashboard, proof of value.

Plus

$10/mo

10 displays

Home power users and micro-businesses.

Fleet+

$49/mo

200 displays

Larger SMB and MSP deployments.

Compare plans in detail

Common questions

Do I need to know Linux to use this?

No. You flash the image, plug the Pi into a screen and network, and the screen shows a pairing code. Everything after that happens in the portal. There is no shell, no config file, and no kiosk flags to set.

What hardware do you support?

Raspberry Pi 4 (2 GB or more) and Raspberry Pi 5 today. A generic Linux/x86 player is next. We keep the supported list short on purpose so every combination is actually tested.

Is this digital signage?

Not really. Signage products are built around campaigns, templates, and playlists. DisplayOps is built around the screen itself: keeping a URL, dashboard, or simple content live and recoverable. If you need a design suite, we are not it.

Can it show a dashboard that needs a login?

Public and token-based dashboards work today, which covers most Grafana, Home Assistant, and status-board setups. Managed authenticated sessions are on the roadmap and are being treated as a deliberate security project, not a checkbox.

What happens when the internet drops?

The device keeps showing what it has, caches web and media content locally where it can, and reconnects on its own. You see the offline event in the portal and the screen converges to the desired state when it is back.

How is pricing counted?

By plan, not per screen. Pick the tier that fits your fleet size. Website displays are effectively free to run; heavy video across many screens is covered by fair-use limits so the price can stay flat.

Can I control screens from my own systems?

Yes. The API and webhooks are first-class. Change a URL from a CI job, rotate dashboards from a script, or push an emergency message from an alert.

Connect a screen. Tell it what to display. We keep it running.

Three displays are free. No card, no sales call, no signage jargon.