DEV Community

Cover image for I Built an Open-Source Endpoint Manager Because Enterprise Tools Are Ridiculous
Benedikt Schackenberg
Benedikt Schackenberg

Posted on

I Built an Open-Source Endpoint Manager Because Enterprise Tools Are Ridiculous

#opensource #devops #sysadmin #selfhosted

Let me start with a confession: I have too many computers.

Three Windows Servers, a handful of workstations, a Linux box running... stuff. You know how it goes. One day you're setting up a home lab, next thing you know you're managing a small fleet and wondering which machine has that outdated Log4j version.

Commercial endpoint management tools exist, sure. But have you seen the pricing? We're talking $10-15 per endpoint per month for the basics. PDQ Deploy wants $500/year minimum. Microsoft Intune is... well, it's Microsoft. And don't get me started on trying to self-host SCCM.

So I did what any reasonable developer does when faced with expensive software: I built my own.

Meet Octofleet

Octofleet Dashboard

Octofleet is an open-source endpoint management platform. It's what I wished existed when I started looking for solutions: simple to deploy, actually useful, and doesn't require a finance department to approve.

Fair warning: This is still beta software. I'm running it in production on my own infrastructure (because I like living dangerously), but you should probably test it properly before deploying to anything critical. That said — it works, and it's been stable for weeks now.

What It Actually Does

The feature list grew organically from "things I kept needing":

Hardware & Software Inventory
Every machine reports what's installed, what hardware it has, disk space, network adapters — the works. I got tired of RDP-ing into servers just to check if something was installed.

Remote Job Execution
Run PowerShell scripts or Bash commands across your fleet. Schedule them, target specific groups, see results in real-time. No more "let me just quickly SSH into 5 machines to check something."

Vulnerability Scanning
This one surprised me how useful it became. The platform pulls CVE data from NVD and cross-references it with installed software. Suddenly I knew exactly which machines had vulnerable versions of stuff I'd forgotten I installed.

Auto-Remediation
Found a vulnerability? Octofleet can automatically update the affected software via winget or Chocolatey. It's like having a very focused, very patient sysadmin working 24/7.

Performance Monitoring
Real-time CPU, RAM, and disk metrics with a "hotspot matrix" that shows you at a glance which machines need attention. No more guessing which server is struggling.

Performance Hotspot Matrix

The Architecture (For Those Who Care)

I went with a stack I actually enjoy working with:

┌─────────────────────────────────────────────┐
│              Frontend (Next.js)             │
│            React + Tailwind CSS             │
└──────────────────┬──────────────────────────┘
                   │ REST API
┌──────────────────▼──────────────────────────┐
│              Backend (FastAPI)              │
│               Python 3.12                   │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│      PostgreSQL 16 + TimescaleDB            │
│         (for time-series metrics)           │
└─────────────────────────────────────────────┘

    ┌─────────┐  ┌─────────┐  ┌─────────┐
    │ Windows │  │ Windows │  │  Linux  │
    │  Agent  │  │  Agent  │  │  Agent  │
    │ (.NET 8)│  │ (.NET 8)│  │ (Bash)  │
    └────┬────┘  └────┬────┘  └────┬────┘
         └────────────┴────────────┘
               HTTPS polling
Enter fullscreen mode Exit fullscreen mode

Why TimescaleDB? Because storing weeks of performance metrics in regular PostgreSQL tables gets ugly fast. TimescaleDB handles time-series data compression and retention automatically.

The Windows agent is a single .NET 8 executable (~8MB) that runs as a service. No installer dependencies, no runtime requirements on the target machine. The Linux agent is a bash script because... sometimes simple wins.

Getting Started

If you want to try it:

git clone https://github.com/BenediktSchackenberg/octofleet.git
cd octofleet
docker compose up -d
Enter fullscreen mode Exit fullscreen mode

That's it. Open http://localhost:3000, login with admin/admin, and you've got a running instance.

For agents, there's a one-liner for Windows:

iwr "https://raw.githubusercontent.com/BenediktSchackenberg/octofleet/main/Install-OctofleetAgent.ps1" -OutFile "$env:TEMP\install.ps1"; & "$env:TEMP\install.ps1"
Enter fullscreen mode Exit fullscreen mode

The agent auto-registers with your server and starts reporting immediately.

How It Compares

I'm not going to pretend Octofleet replaces enterprise solutions. But for homelabs, small businesses, or anyone who just wants basic fleet management without the complexity:

Feature Octofleet PDQ Deploy NinjaRMM SCCM
Price Free $500+/yr $3+/endpoint/mo LOL
Self-hosted ✅ ✅ ❌ ✅
Setup time 5 min 30 min 15 min Days
Linux support ✅ ❌ ✅ Kinda
Vuln scanning ✅ ❌ ✅ ✅
Open source ✅ ❌ ❌ ❌

The big players have more features, better polish, enterprise support. But they also have enterprise complexity and enterprise pricing. Pick your poison.

The Honest "Beta Software" Section

Things that work well:

  • Inventory collection is solid
  • Job execution is reliable
  • The dashboard is genuinely useful day-to-day
  • Auto-updates for agents work (finally, after some painful debugging)

Things I'm still working on:

  • Documentation could be better (it exists, but it's... sparse)
  • macOS agent doesn't exist yet
  • Reporting/exports are basic
  • No mobile app (and probably never will be)

Known quirks:

  • First-time setup needs you to configure the gateway URL manually
  • Some edge cases in vulnerability matching (CVE data is messy)
  • The UI has some rough edges on mobile

Why I'm Sharing This

Honestly? I want feedback.

This started as a personal project to scratch my own itch. But it's grown into something that might be useful for others, and I'd love to know:

  • What features are missing that would make this useful for you?
  • What's confusing about the setup?
  • What breaks when you try it?

I'm also very open to contributions. The codebase is reasonably clean (I think), the stack is modern, and there's plenty of low-hanging fruit for anyone wanting to contribute to an open-source project.

Links

If you try it, let me know how it goes. Open an issue, leave a comment here, or just star the repo if you think it's cool.

And if you're running a fleet of machines and paying too much for basic management tools — maybe give this a shot. Worst case, you'll have wasted 5 minutes on docker compose up. Best case, you'll save a bunch of money and have something you can actually customize.

Currently managing 9 endpoints with Octofleet. My wallet is happier, even if my spare time isn't.

Top comments (0)