Hubleys

Hubleys is a lightweight, self‑hosted personal dashboard designed to centralize access to a variety of services while preserving fine‑grained user permissions. From a developer’s standpoint, it functions as an extensible web application that aggregates static link tiles, search utilities, calendar events, weather widgets, and simple timers into a single responsive interface. The core of Hubleys is built around the idea that an administrator can pre‑define a curated set of resources, and each authenticated user receives a personalized view that respects group membership and individual settings.

Technical Stack

Hubleys is written in TypeScript and runs on a modern JavaScript runtime (node/pnpm). The server side uses Express as the HTTP framework, while the client is a React SPA served from the same process. Persistent state lives in the local filesystem under a /data directory; the application serializes configuration and user settings to YAML/JSON files. No external database is required, which simplifies deployment: a single container with a bind mount suffices for most use cases. The stack is deliberately minimal, yet it leverages well‑maintained libraries such as YAML, dayjs for dates, and axios for HTTP requests to third‑party APIs like OpenWeatherMap and Unsplash.

Core Capabilities

• Role‑based dashboards: Admins can assign users to groups, and each group gets its own set of link tiles and folders. Permissions are enforced at the route level, ensuring that users cannot view or modify content they are not granted.
• Dynamic widgets: The dashboard supports a plug‑in style architecture where new components (e.g., a custom weather provider or calendar integration) can be added by extending the widgets directory and updating config.yml.
• RESTful API: Hubleys exposes a lightweight JSON API for CRUD operations on link tiles, folders, and user settings. The API is versioned (/api/v1/...) and uses standard HTTP status codes, making it straightforward to integrate with external automation tools.
• Webhooks & Automation: External services can trigger updates by posting to the /webhook/events endpoint, allowing for real‑time calendar or weather refreshes without manual intervention.

Deployment & Infrastructure

Because Hubleys stores all state on disk, it is trivially container‑friendly. The provided Docker image includes a Dockerfile that sets environment variables for API keys, admin definitions, and data paths. Deployment typically involves a simple docker‑compose snippet with a single service, but the application can also run in Kubernetes as a stateless pod that mounts a persistent volume. Resource usage is modest—default memory limits are 100 MiB, and CPU consumption remains below 200 mCPU under normal load—making it suitable for edge devices or small‑scale deployments.

Integration & Extensibility

The application’s plugin system is file‑based: any JavaScript module placed under src/widgets can register itself by exporting a component and metadata. This design allows developers to add new widgets without touching the core codebase, simply by committing the module and restarting the container. Additionally, Hubleys supports custom background collections; images dropped into /data/wallpaper become selectable backgrounds for users, and the API can expose these as a resource. The public config.yml format is YAML‑based, so external tooling (e.g., CI pipelines) can generate or validate configuration before deployment.

Developer Experience

Hubleys prides itself on clear, self‑contained documentation. The README walks through Docker setup, environment variables, and the filesystem layout in detail. Configuration files are human‑readable (YAML/JSON), enabling version control and auditability. The community around Hubleys is modest but active on GitHub, with issues typically resolved within a day. The codebase follows TypeScript conventions and includes type definitions for all public APIs, which aids IDE auto‑completion and static analysis.

Use Cases

• DevOps Teams: Centralize access to internal dashboards, CI/CD pipelines, and monitoring tools while enforcing RBAC.
• Small SaaS Operators: Offer a branded self‑hosted portal for customers to access product links, knowledge bases, and support tickets.
• Personal Projects: Create a private home server dashboard that aggregates personal links, weather forecasts, and calendar events without exposing raw URLs.
• Educational Environments: Provide students with a single entry point to learning resources, project repositories, and scheduling tools.

Advantages

Hubleys delivers a compelling mix of simplicity and flexibility. Its file‑based persistence eliminates database maintenance overhead, while the plug‑in architecture allows developers to tailor the dashboard to niche requirements. The application is open source under a permissive license, giving teams full control over customization and distribution. Performance is optimized for low memory footprints, making it an excellent choice for resource‑constrained environments such as Raspberry Pi or home NAS setups. Overall, Hubleys offers a developer‑friendly, low‑barrier entry into building personalized service portals that can scale from single users to dozens of team members.