What A Self-hosted Dashboard Looks Like On 315 Inches Of Colour E-ink

What A Self-hosted Dashboard Looks Like On 315 Inches Of Colour E-ink

INTRODUCTION

The landscape of self-hosted infrastructure has evolved dramatically over the past decade. From modest homelab setups running on repurposed hardware to sophisticated enterprise-grade deployments, the desire to monitor and control systems locally rather than relying on cloud services has grown exponentially. At the heart of this movement lies a fundamental question: how do we effectively visualize complex system metrics in a world increasingly dominated by ephemeral cloud dashboards and SaaS platforms?

The answer often lies in reconsidering traditional approaches to system monitoring. While tools like Grafana, Prometheus, and Datadog have become industry standards, they typically rely on web-based interfaces that, while powerful, can feel disconnected from the physical reality of the infrastructure they represent. This is where the intersection of e-ink technology and self-hosted monitoring becomes particularly interesting.

Consider a scenario involving a 31.5-inch colour e-ink display—specifically the Fraimic Large Canvas—running continuous system visualizations. This isn’t merely about having a large screen; it’s about creating a persistent, low-power, always-visible window into your infrastructure’s health. The display becomes more than a monitor; it transforms into a living status board, a silent communicator of your systems’ wellbeing.

This comprehensive guide explores the ecosystem of self-hosted dashboards, with particular focus on technologies that render to e-ink displays. We’ll examine Tesserae, a notable player in this space, and use its architecture as a springboard for discussing broader principles of infrastructure visualization, Docker-based deployment, and the unique considerations of e-ink rendering environments.

UNDERSTANDING THE TOPIC

What Is Tesserae?

Tesserae represents a fascinating convergence of several DevOps trends: the rise of self-hosted alternatives to proprietary monitoring stacks, the growing interest in e-ink display technology for always-on visualizations, and the AGPL-3.0 licensing model that ensures transparency and community contribution. At its core, Tesserae functions as a server that accepts dashboard definitions composed in a browser, renders them headlessly, and pushes the resulting frames to e-ink panels connected to the network.

The architecture is deliberately straightforward. A user composes a dashboard configuration through a web interface, specifying which metrics to display, how to visualize them, and the overall layout. Tesserae then takes this configuration, renders it using headless Chrome or similar technology, and transmits the resulting image data to the connected e-ink display. The entire process can operate as a Docker container or as a Home Assistant add-on, making it accessible to a wide range of homelab enthusiasts and professional sysadmins alike.

Historical Context and Development

The concept of dedicated monitoring displays isn’t entirely new. In the early 2000s, it was common to see large CRT monitors in server rooms displaying real-time system metrics. However, the technology landscape has shifted significantly. LCD monitors became the standard, followed by the rise of mobile devices and cloud-based dashboards. E-ink technology, originally developed for e-readers, has found new life in industrial and homelab applications.

Tesserae emerged from the recognition that while tools like Grafana excel at interactive web-based monitoring, there’s a place for persistent, low-maintenance displays that don’t require constant interaction. The project’s AGPL-3.0 license ensures that the source code remains freely available for modification and inspection, aligning with the philosophies of the broader self-hosted community.

Key Features and Capabilities

Tesserae’s feature set reflects its design philosophy of simplicity and functionality:

• Browser-based dashboard composition: Users define their dashboards through a web interface, eliminating the need for YAML configuration files or command-line parameter tuning for basic setups.
• Headless rendering: The server uses headless browser technology to render dashboard designs, ensuring that what you see in the composition interface matches what appears on the display.
• Docker and Home Assistant integration: The software runs as a containerized application, with official support for both standalone Docker deployments and Home Assistant add-ons. This flexibility means it can run on everything from a dedicated homelab server to a modest Raspberry Pi running Home Assistant.
• No authentication requirements: Tesserae operates without user accounts or authentication mechanisms. This design choice simplifies deployment but means it’s best suited for internal networks rather than exposed public-facing installations.
• AGPL-3.0 licensing: The open-source nature of the project allows for inspection, modification, and self-hosting without licensing constraints.

Pros and Cons

Like any technology, Tesserae presents trade-offs that must be considered in the context of your specific use case:

Advantages:

• Low resource footprint: The application is designed to be lightweight, making it suitable for deployment on modest hardware.
• Persistent visualization: Once configured, the dashboard runs continuously without requiring user interaction or scheduled refreshes.
• Color e-ink support: Unlike monochrome e-ink displays, colour support enables more sophisticated visualizations with differentiated colors for different metric categories.
• Headless operation: Ideal for homelab environments where you want monitoring without a constant browser tab open.
• Community-driven: The AGPL-3.0 license fosters community contributions and transparency.

Considerations:

• Network dependency: The system requires network connectivity between the Tesserae server and the e-ink display.
• Rendering limitations: Headless rendering may not perfectly replicate all web-based visual effects, particularly complex animations or CSS-based effects.
• Single-purpose design: Tesserae is optimized for e-ink dashboard rendering rather than general-purpose monitoring.
• No built-in authentication: As mentioned, this requires careful network segmentation if deployed in less trusted environments.

Use Cases and Scenarios

The Tesserae architecture addresses several specific scenarios within the DevOps and homelab ecosystems:

1. Server room status boards: A large e-ink display in a server room showing current load, active services, and health status without requiring staff to log into web interfaces.
2. Home automation integration: Running as a Home Assistant add-on to display system metrics, weather information, or automation status on a dedicated wall-mounted display.
3. Development team visibility: Teams working in shared physical spaces can have constant awareness of build statuses, deployment pipelines, or service health without interrupting their workflow.
4. Disaster recovery monitoring: During incident response, having a persistent display of critical system metrics can inform decision-making without requiring terminal access.
5. Educational environments: Teaching infrastructure concepts with visual representations that remain visible without constant computer access.

Current State and Future Trends

The self-hosted monitoring landscape continues to evolve. While established tools like Grafana remain dominant for interactive web-based dashboards, there’s growing interest in persistent, always-visible displays for specific use cases. The Tesserae project exemplifies this trend, but it’s part of a broader movement that includes:

• Integration with Prometheus and Grafana: Some projects aim to bridge the gap between traditional monitoring stacks and e-ink displays, allowing organizations to leverage existing metric collection while adding persistent visualization.
• Low-power always-on displays: As e-ink technology improves and becomes more affordable, we’re seeing increased adoption in various settings from retail to industrial to homelab environments.
• Hybrid approaches: Combining web-based interactive dashboards with persistent e-ink status boards, each serving different purposes in the same infrastructure.
• Improved rendering engines: Headless browser technology continues to advance, potentially reducing the rendering limitations that currently exist.

How It Compares to Alternatives

When evaluating Tesserae against other monitoring visualization approaches, several distinctions emerge:

vs. Grafana: Grafana offers far more sophisticated visualization options, alerting capabilities, and query languages. However, it requires a web browser for interaction and typically runs on higher-power hardware. Tesserae sacrifices depth for persistence and low power consumption.

vs. Prometheus Alertmanager: Alertmanager can send notifications to various endpoints, but configuring it for persistent e-ink display requires additional scripting and infrastructure. Tesserae provides a more opinionated, turnkey solution.

vs. Custom Python/Node.js scripts: Building custom dashboard renderers offers maximum flexibility but requires significant development effort. Tesserae provides immediate functionality with community-supported features.

vs. Commercial SaaS dashboards: Self-hosted solutions like Tesserae eliminate ongoing costs and data privacy concerns, though they require operational expertise for deployment and maintenance.

Real-World Applications and Success Stories

While specific case studies of Tesserae deployments may be limited due to the project’s relative niche, the underlying use case is well-established. Organizations running homelabs frequently report deploying dedicated monitoring displays. Common patterns include:

• Small businesses using a single large screen in the office to show website uptime, server health, and basic infrastructure metrics.
• DevOps teams in larger organizations using e-ink displays in break rooms or common areas to show build pipeline status or deployment health.
• Educational institutions using the technology to teach infrastructure concepts with tangible, always-visible representations.
• Remote work setups where distributed teams use personal e-ink displays to monitor their home infrastructure’s health.

The Fraimic Large Canvas, with its 31.5-inch colour e-ink panel, represents the upper end of what’s feasible for homelab deployments. Its size makes it suitable for wall mounting in dedicated spaces, while colour support enables more nuanced visualizations than monochrome alternatives.

PREREQUISITES

System Requirements

Before deploying Tesserae or similar self-hosted dashboard rendering software, several prerequisites must be addressed. These requirements ensure that the installation proceeds smoothly and that the resulting system performs optimally.

Hardware considerations:

• E-ink display: The Fraimic Large Canvas or similar 31.5-inch colour e-ink panel. These displays typically connect via HDMI or DisplayPort to a rendering host.
• Rendering host: A device capable of running Docker and supporting headless browser operations. This could be a dedicated server, a virtual machine, or a single-board computer like a Raspberry Pi 5 (though the 31.5-inch display would require a more powerful host for acceptable performance).
• Network connectivity: Both the rendering host and the e-ink display must be on the same network, with adequate bandwidth for transmitting rendered dashboard frames.

Operating system requirements:

• Linux is the primary supported platform for Docker-based deployments.
• Docker Engine version 20.10 or newer is recommended for optimal container compatibility.
• For Home Assistant add-on deployment, Home Assistant OS running on compatible hardware (typically x86_64 architecture).

Dependencies:

• Docker must be installed and running.
• Depending on the rendering approach, Chromium or Chrome headless may need to be available within the container environment.
• Network configuration allowing outbound connections if the dashboard composition interface requires external resources.

Required Software

The software ecosystem for a Tesserae deployment includes several components:

1. Tesserae server: The core application, available as a Docker image or Home Assistant add-on.
2. Docker Engine: For container execution and management.
3. Headless browser: Chromium or Chrome in headless mode, typically bundled within the Tesserae container.
4. E-ink display firmware: The Fraimic display requires specific firmware to accept and render image data transmitted from the server.
5. Network tools: For configuring static IP addresses, DNS resolution, and firewall rules if needed.

Network and Security Considerations

Network architecture plays a crucial role in Tesserae deployment success. The system’s design—specifically the decision to operate without authentication—means that network security becomes the primary protective layer.

Network topology:

• Internal network: Tesserae performs best on trusted internal networks where all connected devices are under administrative control.
• Network segmentation: Consider placing the e-ink display and Tesserae server on a dedicated VLAN or network segment to reduce the attack surface.
• Port requirements: The application typically listens on port 8080 for the web-based dashboard composition interface and may use additional ports for communication with the e-ink display controller.

Security best practices:

• Firewall rules: Restrict access to the Tesserae web interface to specific IP ranges or subnet ranges.
• Reverse proxy: Consider placing Tesserae behind a reverse proxy like Nginx or Traefik for additional configuration options including TLS termination, though the application itself doesn’t natively support HTTPS.
• Regular updates: Keep the Tesserae container and underlying host OS patched to address any security vulnerabilities discovered in dependencies.
• Physical security: The e-ink display itself should be physically secured, as it may display sensitive system information.

User Permissions and Access Levels

Understanding user permissions is essential for proper deployment:

• Root access: Required for Docker installation and container management on the host system.
• Docker group membership: Users needing to manage containers should be added to the docker group, or Docker should be configured for rootless operation.
• Web interface access: The dashboard composition interface is accessible via HTTP to any user on the network (due to the no-auth design). Administrative access to the container configuration requires knowledge of the Docker command line or Home Assistant add-on configuration.
• Display access: The e-ink display typically operates without user authentication, receiving frames from Tesserae based on network connectivity.

Pre-Installation Checklist

Before beginning the installation process, verify the following:

• Hardware compatibility: Confirm that the e-ink display (Fraimic Large Canvas or similar) is supported and that the rendering host has appropriate video output connections.
• Docker availability: Docker Engine is installed and running on the target host.
• Network reachability: The host can resolve DNS names and has outbound internet access if the dashboard composition interface requires external resources.
• Disk space: Adequate storage for the Tesserae container image and any persistent configuration data (typically minimal, but verify available space).
• Memory requirements: Ensure the host has sufficient RAM for Docker container operation and headless browser processes (1GB minimum recommended, 2GB+ for optimal performance).
• Display configuration: The e-ink display is powered on and set to the correct input source matching the host’s video output.
• Backup strategy: While Tesserae itself may not require extensive backups, ensure that any dashboard configurations composed through the web interface are documented or exported if the application supports it.

INSTALLATION & SETUP

Docker Deployment

The Docker-based installation of Tesserae represents the most flexible deployment method, suitable for standalone servers, virtual machines, and environments where Home Assistant isn’t the primary platform.

Pulling the Tesserae Docker image:

docker pull tesserae/tesserae:latest

This command retrieves the latest Tesserae container image from the project’s container registry. The image includes the Tesserae server, headless browser dependencies, and the necessary configuration for e-ink frame transmission.

Running the container:

docker run -d \
  --name=$CONTAINER_NAME \
  -p 8080:8080 \
  -v $HOME/tesserae/config:/config \
  --restart=unless-stopped \
  tesserae/tesserae:latest

Command breakdown:

• docker run -d: Runs the container in detached mode (background).
• --name=$CONTAINER_NAME: Assigns a name to the container for easy reference. Using the $CONTAINER_NAME variable follows the specified syntax requirements.
• -p 8080:8080: Maps port 8080 on the host to port 8080 within the container. This is the port through which the dashboard composition interface will be accessible.
• -v $HOME/tesserae/config:/config: Mounts a host directory to /config within the container. This volume persists dashboard configurations, ensuring they survive container restarts. The $HOME/tesserae/config path uses the $HOME variable syntax.
• --restart=unless-stopped: Ensures the container automatically restarts unless explicitly stopped, providing persistence across host reboots.
• `tesserae/tesserae: