#self-hosting

flagd is a feature flag evaluation engine. Think of it as a ready-made, open source, OpenFeature-compliant feature flag backend system.

With flagd, you can:

• modify flags in real-time
• define flags of various types (boolean, string, number, JSON)
• use context-sensitive rules to target specific users or user traits
• perform pseudorandom assignments for experimentation
• perform progressive roll-outs of new features
• aggregate flag definitions from multiple sources
• expose aggregated flags as a gRPC stream to be used by in-process providers
• expose OFREP service for configured flags

It doesn't include a UI, management console or a persistence layer. It's configurable entirely via a POSIX-style CLI. Thanks to its minimalism, it's extremely flexible; you can leverage flagd as a sidecar alongside your application, an engine running in your application process, or as a central service evaluating thousands of flags per second.

The self-hostable alternative to Dropbox and Google Drive. Upload, organize, and share files from your own infrastructure.

Bring your own storage — local disk, S3, R2, or Vercel Blob. One env var to switch. Full type-safe API with tRPC.

Very cool.

Next.js 16 with App Router, PostgreSQL with Drizzle ORM, tRPC for type-safe APIs, BetterAuth for authentication, and Tailwind CSS for the UI. The project uses a Turborepo monorepo with pnpm workspaces.

Oof. This Vercel-based stack is hard for me to swallow.

Multi-Store Replication

Attach multiple storage backends per workspace. Designate a primary store, fan out writable replicas for redundancy, and ingest files from read-only sources.

Neat. Almost no backup needed.

Search Inside Images & PDFs

Find files by what's in them, not just the name. Locker transcribes images and PDFs into searchable text so every document is discoverable.

Smart.

Virtual Bash Shell

Navigate your files with familiar commands. Use ls, cd, find, cat, and grep through a virtual filesystem API.

Love the idea of this, but it's not a CLI per se, it's an API you can use via tRPC.

ONCE is a platform for installing and managing Docker-based web applications. Its goal is to make self-hosting applications as simple as possible.

As well as simplifying the initial setup, ONCE also provides automatic updates, backups, and system information. It has a TUI interface with a dashboard for monitoring and operating your applications, as well as CLI commands for common operations should you (or your AI agent) prefer that.

ONCE runs on Linux and macOS, and can be used to run applications on a variety of hardware: a physical server, a cloud VPS, a Raspberry Pi, or your laptop, are all suitable.

Our stack for bringing home all these applications is entirely open source. We use KVM to slice our new monster 192-thread Dell R7625s into isolated VMs, then Docker to run the containerized applications, and finally Kamal to do zero-downtime app deploys and rollbacks. This setup helped us dodge the complexity of Kubernetes, and avoid any sort of enterprisey service contract entanglements.

The back of the napkin math is that we'll save at least $1.5 million per year by owning our own hardware rather than renting it from Amazon. And crucially, we've been able to do this without changing the size of the operations team at all. Running our applications in the cloud just never provided the promised productivity gains to do with any smaller of a team anyway.

The main difference here is the lag time between needing new servers and seeing them online. It truly is incredible that you can spin up 100 powerful machines in the cloud in just a few minutes, but you also pay dearly for the privilege. And we just don't have such an unpredictable business as to warrant this premium. Given how much money we're saving owning our own hardware, we can afford to dramatically over-provision our server needs, and then when we need more, it still only takes a couple of weeks to show up.

Whether that’s low-cost cloud options without the managed-service markup from the likes of Digital Ocean, Hetzner, OVH, etc, or it’s your own colocated bare metal. To Kamal, it’s all the same. Feed the config file a list of IP addresses with vanilla Ubuntu servers that have seen no prep beyond an added SSH key, and you’ll be running in literally minutes.

Kamal basically is Capistrano for Containers, without the need to carefully prepare servers in advance. No need to ensure that the servers have just the right version of Ruby or other dependencies you need. That all lives in the Docker image now. You can boot a brand new Ubuntu (or whatever) server, add it to the list of servers in Kamal, and it’ll be auto-provisioned with Docker, and run right away. Docker’s layer caching also speeds up deployments with less mucking about on the server. And the images built for Kamal can be used for CI or later introspection.

Kubernetes is a beast. Running it yourself on your own hardware is not for the faint of heart. It’s a fine option if you want to run on someone else’s platform, either transparently like Render or explicitly on AWS/GCP, but if you’d like the freedom to move between cloud and your own hardware, or even mix the two, Kamal is much simpler. You can see everything that’s going on, it’s just basic Docker commands being called.

drive enclosures,

The honest take: Setup time is real. This isn't a weekend project — it took weeks of configuring, breaking, and fixing. But now everything runs 24/7, I own my data, and the monthly cost is basically just electricity (~$10-15/month).

The biggest win? Immich. Having Google Photos-level search (face recognition, location, object detection) on hardware I own, with zero cloud dependency — that alone justified the build.

Video (full build walkthrough): https://www.youtube.com/watch?v=5cET4sfqdlE&t

I'm a plumber by trade who fell into self-hosting, so if I can set this up, anyone can. Happy to answer questions.

Run, manage, and scale AI workloads on any AI infrastructure. Use one system to access & manage all AI compute (Kubernetes, 20+ clouds, or on-prem).

Run by university