DeQ: One Python File Replaces Your Entire Homelab Stack

What if I told you that everything you're running in your homelab—the Docker^{↗ Bright Coding Blog} containers, the wake-on-LAN scripts, the monitoring dashboards, the file managers, the scheduled backups—could be controlled by a single Python^{↗ Bright Coding Blog} file weighing just 350 KB?

No Kubernetes. No Docker Compose orchestration layers. No YAML-induced headaches. No npm install running for twenty minutes only to fail on node-gyp.

Just one file. server.py. Running on your server, talking to your devices through raw SSH, and presenting itself through a gorgeous mobile-first web interface that syncs with a native Android app, Wear OS, and even Android Auto.

This isn't a fever dream of a minimalist developer. This is DeQ—the homelab control plane that top self-hosters are quietly adopting while everyone else drowns in configuration complexity. If you've ever caught yourself thinking, "There has to be a simpler way," you're about to discover that someone finally built it. And the results are nothing short of liberating.

What Is DeQ?

DeQ is an ultra-lightweight, SSH-based network control layer designed specifically for homelab enthusiasts who value function over ceremony. Created by the team at deq.rocks, it strips away the abstraction towers that modern infrastructure tools love to build, exposing the raw power of SSH through an elegant, responsive interface.

The project's philosophy is disarmingly simple: "Less, but better. Lateral thinking over complexity." In practice, this means DeQ uses what's already on your Linux systems—Python and SSH—and wraps them in a thin, vanilla shell that requires zero dependencies.

Here's what makes DeQ genuinely radical in today's landscape: while competitors ship with hundreds of megabytes in containers, sprawling configuration files, and dependency trees that break quarterly, DeQ deliberately constrains its core to a maximum of 500 KB. The current server.py sits comfortably around 350 KB. A fresh installation managing multiple devices, containers, and scheduled tasks consumes roughly 20 MB of RAM and virtually no CPU.

DeQ isn't a dashboard. It's a control layer disguised as a dashboard—a well-connected nerve center with direct access to core homelab functions: Wake-on-LAN, task scheduling, file management, device monitoring with alarm thresholds, and even sensor context from your mobile devices. The native Android app, Android Auto integration, and Wear OS support aren't afterthoughts bolted onto a web project. They're first-class citizens that sync directly with your server.py instance.

The project is released under CC BY-NC 4.0—free for personal use, with commercial licensing available. It's actively developed with a Patreon-backed full-time effort, ensuring continuous improvements rather than the abandonware fate that befalls so many promising homelab tools.

Key Features That Eliminate Complexity

DeQ's feature set reads like a wishlist from every homelab operator who's ever screamed at a misconfigured reverse proxy. Let's dissect what makes each capability genuinely useful:

Automatic Onboarding — DeQ discovers and populates your devices and containers automatically. No manual entry of IP addresses, no hunting for MAC addresses in DHCP leases. The system maps your network intelligently, reducing setup friction from hours to minutes.

Native Android Ecosystem — This isn't a wrapped webview. The free Android app provides background monitoring with push notifications when devices drop offline, containers stop unexpectedly, or backup jobs fail. The Pro tier (€6.99) unlocks widgets, live wallpaper, ambient mode for wall-mounted displays, Android Auto integration for in-car status checks, and Wear OS support with tiles and complications.

DeQ Nodes & Wake-on-LAN — Devices running the app connect to a node network capable of sending Wake-on-LAN magic packets to sleeping servers—even when you're away from home. Your homelab becomes truly accessible from anywhere without keeping everything powered 24/7.

Device Control & Monitoring — Execute shutdowns, suspends, and Docker start/stop operations directly. Monitor CPU load, temperatures, and SMART drive health with configurable alarm thresholds that push to your phone.

Dual-Pane File Manager — Browse, copy, move, and upload files between devices through a responsive dual-pane interface that works identically on desktop browsers and mobile screens.

Scheduled Tasks with Wizard — Build automated backups, wake schedules, shutdown sequences, and custom script execution through a guided wizard—no cron syntax memorization required.

Extension API & HTTP API — Write Python extensions to add custom sections to the web interface. Connect Home Assistant, Tasker, or build entirely custom automations through the HTTP API. Drop shell scripts into /opt/deq/scripts/ for quick automation.

Theming & PWA — Custom colors, wallpapers, transparency effects. Install as a Progressive Web App on any device for native-like experience without store submissions.

Admin Auth Layer — Additional security beyond SSH keys, ensuring your control plane stays protected.

Real-World Use Cases Where DeQ Dominates

The Power-Conscious Homelab

You're running a rack in your closet with monthly electricity bills that make your spouse suspicious. DeQ's Sleep With Me feature detects when you plug in your phone at night and automatically suspends selected containers and servers—waking them when you unplug in the morning. Combined with Wake-on-LAN, you maintain 24/7 accessibility without 24/7 power draw.

The Mobile Administrator

You're at dinner when your NAS goes offline. Instead of VPNing home, opening a terminal, and running diagnostics, DeQ's Android app pushes a notification with the device status. From your watch, you can trigger a wake command or restart sequence. From Android Auto during your commute, you verify everything's healthy before arriving home.

The Home Assistant Integrator

You've built elaborate automations in Home Assistant but struggle with device control outside the HA ecosystem. DeQ's HTTP API exposes SSH-based control to your existing automations without adding another heavy integration. Trigger server wake before your morning routine starts, or suspend media servers when bedtime mode activates.

The Distributed File Manager

You need to move logs from your Proxmox host to your NAS, then sync specific directories to your cloud backup server. DeQ's dual-pane file manager operates across all connected devices simultaneously—no mounting network shares, no SCP syntax, no rsync flags to remember.

Step-by-Step Installation & Setup Guide

DeQ's installation is deliberately minimal, reflecting its core philosophy. Here's the complete process:

Prerequisites

• A Linux server (Debian, Ubuntu, Arch, or RHEL-based)
• Python 3.x (pre-installed on virtually all modern distributions)
• SSH access to devices you want to control
• Root or sudo privileges for installation

Installation Commands

# Download the latest release
wget https://github.com/deqrocks/deq/releases/latest/download/deq.zip

# Extract and enter directory
unzip deq.zip -d deq && cd deq

# Run the interactive installer
sudo ./install.sh

The installer handles the remaining configuration through interactive prompts:

1. Network Configuration — Confirm or modify the listening interface and port
2. SSH Key Setup — Generate or specify existing SSH keys for device authentication
3. Admin Credentials — Create your administrative authentication layer
4. Device Discovery — Allow automatic network scanning or specify devices manually

Upon completion, the installer presents your access URL. The entire process typically completes in under two minutes.

Post-Installation Configuration

DeQ uses dynamic configuration—no YAML files to edit. All settings are adjusted through the web interface, with changes applied immediately without service restarts.

For the Android app, simply enter your server URL during first launch. The app handles certificate validation, background sync configuration, and notification preferences automatically.

Environment Setup for Extensions

# Create the scripts directory for quick automation
sudo mkdir -p /opt/deq/scripts

# Set appropriate permissions
sudo chown -R $USER:$USER /opt/deq/scripts

# Drop executable scripts here for automatic discovery

For full advanced configuration—including reverse proxy setup, SSL certificate automation, and multi-node networking—refer to the official documentation at deq.rocks/documentation.

REAL Code Examples from DeQ

Let's examine actual implementation patterns from the DeQ repository, demonstrating how this single-file architecture achieves remarkable capabilities.

Example 1: The Core Installation

The entire server deployment is contained in this elegant sequence:

wget https://github.com/deqrocks/deq/releases/latest/download/deq.zip
unzip deq.zip -d deq && cd deq
sudo ./install.sh

What's happening here? The deq.zip release bundles server.py with its installer and static assets. The installer script performs environment detection, dependency verification (confirming Python availability), directory structure creation, systemd service registration, and firewall configuration. The sudo requirement is solely for system-level service installation—DeQ itself runs under its own user context after setup.

This pattern exemplifies deployment minimalism: no package managers to configure, no virtual environments to create, no pip install commands to memorize. The entire control plane arrives as a single downloadable artifact.

Example 2: Extension Script Integration

DeQ's extension system leverages Python's dynamic import capabilities within its constrained architecture. Extensions are placed in designated directories and automatically discovered:

# Conceptual extension pattern based on DeQ's architecture
# Extensions add custom sections to the web interface

# File: /opt/deq/extensions/custom_monitor.py
import json

def register():
    """Called by DeQ on extension discovery"""
    return {
        "name": "Custom Monitor",
        "route": "/ext/custom-monitor",
        "icon": "activity"  # Lucide icon name
    }

def get_data():
    """Returns data for the extension's UI section"""
    # Execute SSH command through DeQ's built-in transport
    # Results are automatically formatted for the dashboard
    return {
        "status": "healthy",
        "custom_metric": 42
    }

Critical insight: DeQ's Extension API doesn't require installing additional Python packages. It operates within the same zero-dependency constraint as the core, using only Python's standard library for HTTP handling, JSON serialization, and subprocess management. This design decision prevents the "dependency drift" that plagues plugin ecosystems.

Example 3: HTTP API for External Integration

The HTTP API enables Home Assistant and Tasker connectivity without dedicated integrations:

# Wake a specific device via HTTP API
# Authentication uses the admin layer configured during install
curl -X POST https://your-deq-server/api/wake \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"device": "nas-server", "method": "wol"}'

# Check device status for automation triggers
curl -X GET https://your-deq-server/api/status/nas-server \
  -H "Authorization: Bearer YOUR_TOKEN"

Integration power: These endpoints return structured JSON that Home Assistant's REST sensor and command_line platforms consume natively. No custom component installation required. Tasker users can build HTTP actions directly, triggering homelab events from phone state changes—location, time, battery level, or connected Bluetooth devices.

Example 4: Shell Script Automation

For operations that don't require Python extensions, simple shell scripts suffice:

#!/bin/bash
# File: /opt/deq/scripts/backup-trigger.sh
# Automatically discovered and executable from DeQ interface

# DeQ exports environment variables for the calling context
# $DEQ_DEVICE: target device hostname
# $DEQ_USER: authenticated user

echo "Starting backup sequence for ${DEQ_DEVICE}..."

# Your custom backup logic here
# rsync, restic, borg—whatever you prefer

# Exit codes surface as notifications in the Android app
exit 0

Operational elegance: Scripts inherit DeQ's SSH session context, eliminating credential management. Exit codes translate directly to push notification states—success, warning, or failure—without explicit notification code.

Advanced Usage & Best Practices

Node Network Optimization — Deploy the Android app on multiple devices (phone, tablet, old phone as wall display) to create redundant node paths for Wake-on-LAN. If your primary phone is dead, the tablet still reaches sleeping servers.

Ambient Mode Deployment — Convert an old Android phone with OLED screen into a permanent wall display. The Pro app's ambient mode with BCD clock provides at-a-glance status while minimizing burn-in. Position near your server rack for immediate visual health indication.

Extension Development Pattern — When building extensions, leverage DeQ's built-in SSH transport rather than creating independent connections. This centralizes authentication, logging, and error handling. Cache expensive operations using simple file-based storage in /opt/deq/cache/.

Security Hardening — While DeQ adds an admin auth layer, implement network-level controls: restrict server.py to VPN interfaces or internal VLANs, use SSH key-only authentication for managed devices, and rotate API tokens through the web interface quarterly.

Resource Monitoring Thresholds — Configure aggressive CPU temperature thresholds for summer months and relaxed values for winter, accounting for ambient temperature variations that affect your cooling efficiency.

Comparison with Alternatives

Why DeQ wins: Alternatives excel at specific functions—Portainer for Docker management, Homer for service dashboards—but require stacking multiple tools for complete homelab control. DeQ's radical constraint to a single file eliminates integration complexity while matching or exceeding functionality through direct SSH access rather than API abstractions.

FAQ

Is DeQ really just one Python file? Yes. server.py contains the entire server-side control layer. The release zip includes this file, static web assets, the installer, and documentation. No pip install, no requirements.txt, no container images.

How does DeQ handle security without dependencies? DeQ leverages Linux's native SSH infrastructure for all device authentication and transport encryption. The admin auth layer adds application-level protection. This "use what's there" philosophy avoids the vulnerability surface of additional crypto libraries.

Can I run DeQ without the Android app? Absolutely. The web interface is fully functional across all devices. The Android app, Wear OS, and Android Auto are value-adds for mobile-centric workflows, not requirements.

What devices can DeQ control? Any Linux system accessible via SSH, plus network devices supporting Wake-on-LAN. This includes servers, NAS units, Raspberry Pis, Proxmox hosts, and containers on Docker hosts.

Is there an iOS version planned? Currently, DeQ focuses on the Android ecosystem for native apps. The PWA provides excellent iOS functionality. Check the project's Patreon for roadmap updates.

How do updates work? Re-run the installation commands with the latest release zip. The installer preserves your configuration and applies updates in-place. Dynamic config means no post-update configuration restoration.

Can I use DeQ commercially? The CC BY-NC 4.0 license permits personal use freely. Contact the DeQ team through deq.rocks for commercial licensing inquiries.

Conclusion

DeQ represents something rare in modern infrastructure tooling: genuine restraint. While the industry races toward ever-more-complex orchestration platforms, DeQ proves that a single Python file—350 KB of focused purpose—can outperform stacks orders of magnitude larger for the specific domain of homelab control.

The combination of zero dependencies, dynamic configuration, native mobile ecosystem integration, and direct SSH-based control creates a tool that respects both your time and your server's resources. Whether you're waking a NAS from your watch, scheduling backups through a wizard, or building custom extensions in pure Python, DeQ removes friction without removing capability.

If your homelab management currently involves five browser tabs, three different dashboards, a VPN client, and a prayer that your Docker socket proxy hasn't broken again, it's time for a simpler path. Deploy DeQ in under two minutes and discover what "less, but better" actually feels like.

Get started now: Download DeQ from GitHub or visit deq.rocks for documentation, the Android apps, and community support. Your homelab deserves a control plane that works as hard as you do—without working your hardware to death.