Articles
A practical, security-conscious guide to Linux ownership, modes, groups, ACLs, umask, Docker UID and GID mapping, network shares, SELinux, AppArmor, and permission troubleshooting.
What a Pterodactyl-managed Minecraft server taught me about separating player authorization, account authentication, network exposure, and panel access.
Diagnosing a Docker Swarm service that exists but has no running tasks.
Why a browser-based game that loads successfully can still fail before play, and how to test the real storage budget instead of blaming the network.
What a green GitHub build and a failed Cloudflare deployment taught me about separating source validation, deployment credentials, and the live site.
A practical Linux troubleshooting lesson about separating package installation, service state, and functional validation.
Why an unused computer can be more valuable as known-good recovery capacity than as one more permanent homelab node.
A small homelab port shortage reminded me that physical port count, topology, and device capabilities are different problems, and that hardware purchases should come after understanding the path.
Why having spare machines, spare disks, and a more elaborate architecture available was not enough reason to replace a homelab that already worked.
Why I think Linux Mint, especially Cinnamon, is one of the best places to start when someone wants to leave Windows without relearning the desktop all at once.
What rebuilding an older PC for school taught me about optimizing endpoints for requirements instead of chasing the cleanest possible install.
What maintaining old and current versions of the same application taught me about treating compatibility as a boundary instead of a temporary inconvenience.
I stopped treating outreach like a marketing exercise and started learning what a small business actually gives you time to prove.
How to make UniFi register VLAN-specific hostnames and distribute a shared DNS search list so clients can reach devices by short name across segmented networks.
What an unproven headless-boot failure taught me about separating POST, Linux boot, display output, and service health.
Why putting real work into production changed how I measure progress, choose revisions, and decide when another pass is actually worth doing.
The useful part of a homelab is not copying configurations into production. It is practicing the habits that survive a change in platform, scale, and ownership.
Why I stopped treating completion as a feeling and started defining done through scope, evidence, ownership, reproducibility, and a maintenance path.
Why a game server that worked locally but failed remotely became a better lesson in evidence, network boundaries, and honest troubleshooting than a guessed fix ever could.
How I decide whether a change preserves a service, solves an observed problem, or simply reopens a finished project.
What changed when experimental self-hosted services became useful enough that other people expected them to work.
The retrospective format I use to turn failed assumptions into better tests, guardrails, and documentation without rewriting the project into a cleaner story than it really was.
How I separated a business website from a technical journal without making them look or sound like unrelated projects.
How repeated homelab failures taught me to control uncertainty, separate layers, preserve evidence, and make smaller, more defensible changes.
How the Eldritch IT tagline became a practical test for ownership, documentation, recovery, deployment, and support work.
A practical boundary for publishing useful technical detail without exposing the environment that produced it.
A practical framework for deciding when better hardware saves money and when an expensive purchase only creates a different kind of problem.
What rebuilding a crowded draft queue taught me about overlap, evidence, privacy, and deciding when a field note is actually ready to publish.
Why intake, evidence, trust, escalation, validation, and handoff matter more than treating the installer as the center of Windows recovery.
What enterprise help-desk work taught me about evidence, consistency, escalation, handoffs, documentation, and owning the user's actual outcome.
A practical start-to-finish Ubuntu and Docker walkthrough for building a media automation stack with Sonarr, Radarr, Lidarr, Prowlarr, Bazarr, Seerr, SABnzbd, Deluge, Gluetun, and Jellyfin, adapted from TRaSH Guides and Mathias Furenes' Synology ARR-stack guide.
The concise record that connects requirements, build decisions, validation, recovery, and the next support owner.
How I decide between targeted repair, Windows repair reinstall, Reset this PC, an in-place reinstall, and a clean build without wiping by reflex.
What self-hosted game servers taught me about proving a network path from application startup to a real remote session.
How real build failures taught me about content schemas, layouts, static routes, deployment logs, and the limits of generated code.
Publishing completed technical work forces me to separate evidence from memory, useful architecture from private identifiers, and lessons from the exact environment that produced them.
Separating storage from application compute forced me to define ownership, permissions, failure boundaries, and recovery instead of treating shared disks as a transparent dependency.
Running Pterodactyl at home made game hosting easier, but the bigger lesson was learning to separate management intent, node control, Docker execution, gameplay, storage, and recovery into distinct failure domains.
Separating application compute from authoritative storage made my homelab easier to rebuild, troubleshoot, and change without pretending a second machine is automatic redundancy.
Why rack-unit count stopped being my definition of capacity once I planned around depth, power, airflow, cables, weight, and service access.
A healthy container and an empty media library exposed a quieter failure underneath: the path existed, but the filesystem I expected was not mounted there.
The admission test I use to keep useful homelab services from turning into undocumented maintenance, accidental dependencies, and permanent clutter.
How I validate the original outcome, dependencies, clients, restart behavior, recovery, and failure paths instead of settling for a green dashboard.
How a known Windows baseline made configuration drift useful evidence without pretending every device or user should be identical.
Containers gave my homelab a repeatable application model, but the useful part was the discipline around persistence, networking, updates, and recovery.
Why I replaced an ever-growing pile of utilities with a documented, reproducible set of trusted Windows recovery media and tools.
How repetitive inventory, connectivity, service, file, registry, and event-log questions became small, reviewable PowerShell workflows instead of another layer of complexity.
The layered controls I use so unfinished Markdown can stay in the repository without reaching pages, feeds, search, or build output.
How GPU acceleration reduced CPU pressure without removing codec, subtitle, network, container, and client constraints.
A practical guide to designing, deploying, restricting, validating, and recovering private remote access to a homelab with Tailscale.
A practical change process for protecting state, controlling scope, validating outcomes, and rolling back Docker Compose services deliberately.
Why I capture symptoms, hardware health, logs, data, encryption status, and trust indicators before a broad Windows repair erases the useful context.
How inconsistent Docker mounts create failed imports, duplicate copies, broken hardlinks, and misleading permission errors across a media automation stack.
How inventorying data, configuration, credentials, and restore dependencies exposed what my homelab could and could not actually recover.
Why I chose UniFi for a home network that needed segmentation, wired multi-AP coverage, useful visibility, and room to experiment without becoming a second full-time job.
A practical architecture and operations handbook for planning a homelab from scratch: workloads, hardware, storage, networking, platforms, security, monitoring, backups, recovery, and the order to build them in.
A reference guide to the storage, identity, networking, security, recovery, and service boundaries behind a Docker-based *arr media automation stack.
A practical, start-to-finish guide to deploying, securing, accelerating, backing up, upgrading, and troubleshooting Jellyfin 12 on Ubuntu Server with Docker Compose.
How a collection of useful services became a place to learn networking, storage, containers, recovery, and calmer troubleshooting.
Why I chose Jellyfin for my media library and what running it taught me about storage, containers, networking, metadata, and client devices.
Why Cloudflare fit my requirements for DNS, edge TLS, Git-connected deployment, and public delivery without making the Eldritch IT websites depend on my homelab.
What it took to turn an AI-assisted Astro starter into a site I understood, trusted, and could maintain.
Why I stopped chasing a perfect business website and launched a focused version I could improve with real feedback.
How I split writing, version control, deployment, and public delivery across Astro, GitHub, and Cloudflare.
What I learned by turning Astro's blog starter into a publication I could understand, maintain, and keep improving.
My experience forming Eldritch IT in Texas—and why submitting the paperwork felt more difficult than completing it.
Why I am building a deliberately small IT company around trust, documentation, and stable systems instead of growth for its own sake.
Try a broader term, browse the topic index, or clear the search.