Archives

Deep-dive into actual resource consumption of Multipass GitHub Actions runners — uncovering 85GB of BuildKit cache waste per runner, and a plan to replace it with a shared Docker registry cache.

A practical overview of self-hosted monitoring solutions for server resources and running services — covering tools, common practices, and alerting strategies.

depends_on with conditions, service_healthy, and the traps around startup ordering — because 'started' doesn't mean 'ready'.

Profiles for optional services, .env files for configuration, multiple compose files for overrides — managing complexity in Docker Compose without duplicating everything.

docker compose watch for automatic sync and rebuild — replacing bind mount hacks with a first-class development workflow.

exec, logs, inspect, cp, attach — the toolkit for understanding what's happening inside a container without rebuilding it.

Services, networks, volumes, and the compose file structure — the basics of multi-container applications done right from day one.

Layer caching, BuildKit cache mounts, and registry-based caching — understanding what makes builds slow and how to make them fast again.

The HEALTHCHECK instruction, health states, and how proper healthchecks change restart behavior and service dependency ordering.

docker init generates Dockerfiles, compose files, and .dockerignore for your project — when it saves time and when you should write your own.

FROM, COPY, RUN ordering, layer caching, .dockerignore — the decisions that determine whether your builds are fast and predictable or slow and surprising.

A curated series of Docker articles progressing from fundamentals through Compose to single-server production — each covering one topic in depth with commands, patterns, and gotchas.

docker stats, container events, cAdvisor, and lightweight monitoring stacks — from quick CLI checks to proper dashboards.

How multi-stage Docker builds separate build-time dependencies from runtime, producing smaller and more secure images without complex scripting.

Bridge, host, and custom networks — how containers find each other, when port mapping matters, and how to stop using IP addresses for everything.

Reverse proxies with Traefik and Caddy, TLS termination, internal vs external networks — the networking patterns that take Docker from development to production.

Log drivers, json-file rotation limits, journald integration, and centralized logging — because unlimited container logs will eventually eat your disk.

How to set memory and CPU limits on Docker containers, what happens when they're exceeded, and why running without limits is a production risk.

restart: unless-stopped vs always, systemd integration, and keeping containers alive without an orchestrator.

The mental model behind Docker images, containers, and layers — what actually happens from command to running process, and why understanding the lifecycle matters for everything else.

Non-root users, read-only filesystems, dropped capabilities, and secrets management — the baseline security measures every Docker deployment should have.

Tag strategies, registry basics, and multi-arch builds — shipping Docker images with a system instead of ad-hoc names.

Named volumes, bind mounts, and tmpfs — how Docker handles persistence, when to use each, and the permission problems that catch everyone.

Research into DuckDB — what it is, how it compares to SQLite, ClickHouse, and Polars, and when to use it for local data analysis.

Docker Swarm, Kubernetes, k3s, Nomad, ECS, Cloud Run, Fly.io — when each makes sense, a decision matrix by team size and workload, and the business cases where each wins.

Docker Swarm mode turns a group of Docker hosts into a cluster with built-in service discovery, load balancing, and rolling updates — using the Docker CLI you already know.

Amazon's container orchestration service — EC2 launch type for control, Fargate for serverless containers, and when to choose ECS over EKS.

Docker Swarm, Kubernetes, k3s, Nomad, ECS, Cloud Run, Fly.io — what each does, how to set it up, and when it's the right choice for your team and workload.

A single binary, production-ready Kubernetes distribution — from single-node development to multi-node edge clusters, without the operational weight of full K8s.

Pods, Services, Deployments, and the control loop — understanding Kubernetes architecture and core concepts before touching kubectl.

Run containers without managing infrastructure — Cloud Run and Azure Container Apps handle scaling, TLS, and billing per request.

Deploy-focused platforms that run Docker containers globally — push your code, get a URL, skip the infrastructure.

A simpler alternative to Kubernetes that schedules containers, VMs, Java apps, and batch jobs — with a single binary, no PhD required.

An overview of Sentry, the developer-first error tracking and performance monitoring platform — how it works, what it captures, and how to set it up.

An overview of Umami, the open-source, self-hosted analytics platform that serves as a privacy-respecting alternative to Google Analytics.

A complete guide to converting a desktop machine into a home server running K3s, media services, photo backup, custom web apps, and monitoring — organised as a series of focused articles.

Surveying the 2025-2026 landscape for home server setups: Linux distros, container orchestration, media automation, photo backup, reverse proxies, auth layers, remote access, and monitoring.

Narrowing down from market research to concrete choices: Ubuntu over Proxmox, K3s over Docker Compose, CronJobs over Knative, Jellyfin over Plex, and the honest take on serverless at home.

Installing Ubuntu Server 24.04 with LVM, K3s single-node Kubernetes, storage classes, and Traefik ingress with host-based routing and dashboard.

Deploying the kube-prometheus-stack on K3s via Helm, configuring Grafana dashboards for cluster and system monitoring, and recommended pre-built dashboards.

Deploying Immich on K3s via Helm chart with persistent storage, Traefik ingress, and mobile auto-backup configuration.

Deploying Jellyfin on K3s with shared persistent storage, Traefik ingress, and how it connects to the torrent service for seamless media access.

Deploying qBittorrent with Gluetun VPN sidecar on K3s, Mullvad configuration, shared volumes with Jellyfin, and the web UI download workflow.

The current legal landscape for torrenting in Sweden: copyright law, IPRED enforcement, settlement letters, ISP behaviour, and why download-only is a myth.

The repeatable pattern for hosting your own projects on K3s: namespace-per-app, PostgreSQL/MongoDB, Go/Node/Rust APIs, static frontends, Traefik routing, image builds, deploy scripts, and CronJob scheduling.

Abstract of Anthropic's red-team report on Claude Mythos Preview's unprecedented ability to find and exploit zero-day vulnerabilities across major open-source software.

How to use git clean to remove untracked files, build output, and caches from your working tree — with dry runs, exclusion patterns, and the flags that control what actually gets deleted.

A structured list of questions to help couples align on parenting, finances, responsibilities, and boundaries before the baby comes.

Foundation Capital's research on how companies are reorganizing around AI — and why the real risk isn't job loss but breaking the junior talent pipeline.

How .gitattributes controls merge strategies, diff output, line endings, and export behavior on a per-file or per-pattern basis — solving whole categories of recurring git friction.

How to use git log -S and -G to trace exactly when a string or pattern was added, removed, or changed across the entire history of a repository.

How to use git range-diff to see what actually changed between two versions of a branch — before and after a rebase, or between PR iterations.

How git notes let you annotate commits with additional context — deployment timestamps, review feedback, CI results — without altering commit SHAs or rewriting history.

How git bisect uses binary search to identify the exact commit that introduced a bug — and how to fully automate the process with git bisect run.

How git archive creates tarballs and zip files from any commit, tag, or branch — without the .git directory and with fine-grained control over what gets included.

How to package a git repository or a range of commits into a single portable file — for air-gapped transfers, offline backups, or sharing history without network access.

The flags that make git blame genuinely useful: line ranges, copy detection across files, whitespace-aware attribution, and output formatting for scripts.

How to use .git-blame-ignore-revs to stop formatting-only commits from polluting git blame, preserving the ability to trace actual logic changes back to their authors.

How interactive rebase gives you surgical control over commit history, and how --onto lets you transplant a branch segment onto any base.

How git config aliases can run shell commands, accept arguments, chain multiple operations, and become first-class workflow tools — not just abbreviations.

Named stashes, partial stashing, applying without dropping, creating branches from stashes, and understanding what git stash actually stores.

How git rerere records conflict resolutions and automatically replays them — essential for long-running branches that regularly merge or rebase against a changing base.

How to use git sparse-checkout to work with a subset of a large repository — checking out only specific directories without downloading or materializing the rest.

How git subtree lets you include and sync another repository as a subdirectory — without .gitmodules, detached HEADs, or recursive clone flags.

The difference between lightweight and annotated tags, when to use each, how signing works, and the full workflow for managing release tags in a team repository.

A curated map of underused git features grouped by the situations where they matter most — debugging regressions, reviewing code, managing history, handling large repos, and shipping releases.

How SST's stage model enables per-PR preview environments and automated deployments, with practical GitHub Actions patterns and cost analysis for a solo developer.

A research-driven look at how engineers are using Go and Rust to build high-performance, low-cost serverless web services on AWS, Cloudflare, and GCP.

Core Go syntax, project setup, and mental model shifts for developers coming from the TypeScript/Node.js world.

Deep dive into OpenCode's plugin ecosystem, token optimization tools (RTK equivalents), task planning workflows, and configuration strategies for a solo developer.

Core Rust syntax, ownership model, project setup, and mental model shifts for developers coming from the TypeScript/Node.js world.

Investigating terminal emulator options to replace Alacritty, focusing on macOS full-screen stability with external monitors, cross-platform consistency, and Zellij/Neovim compatibility.

A comparison of static site generators for publishing markdown notes as a structured blog, covering Quartz, Astro/AstroPaper, and Hugo/PaperMod, with notes on search, tags, S3 deployment, and managing draft versus published content.

A summary of a March 2026 HBR study on acute cognitive fatigue caused by AI tool oversight, covering key data points, the productivity paradox, and what organisations can do to mitigate it.

An investigation into using Web Workers with an event-driven message bus to decouple data fetching from React and Svelte render lifecycles, covering transport mechanisms, request deduplication, and practical trade-offs against existing solutions like TanStack Query.

A comparison of free tunneling options for exposing Docker Compose applications to external reviewers without router configuration, covering Cloudflare Tunnel, ngrok, localhost.run, and Tailscale.

An investigation into self-hosted observability alternatives for production Kubernetes applications, comparing a Loki + Grafana + Gatus stack against AWS-native services and managed SaaS, with cost analysis and a phased implementation plan.

A reference overview of Telegram Bot API capabilities covering state management patterns across frameworks, command visibility scoping, keyboard types, Mini Apps, and persistent UI elements like pinned messages.

A survey of approaches for structuring task intake and autonomous execution with AI coding assistants, from native tools to GitHub Issues integration, MCP servers, and enterprise orchestration platforms.

An investigation into combining Cucumber's Gherkin syntax with Playwright for browser automation, covering setup approaches, step reuse patterns, and when the integration is the right choice.

A brief investigation into the right approach for complex radial gradients with aspect-ratio media queries in Tailwind CSS, and why @layer utilities is the recommended escape hatch.

A technical overview of git worktrees — how they work, when to use them, process isolation considerations, and practical management for developers who frequently switch context between branches.

A technical analysis of whether Array.slice() operations in React components warrant useMemo optimisation, with performance benchmarks, practical decision criteria, and common anti-patterns to avoid.

An exploration of what makes a sprint health dashboard useful rather than anxiety-inducing, covering metric selection principles, TV display layout design, and a lightweight technical implementation approach using the GitHub API.

A practical comparison of git merge vs rebase for keeping feature branches in sync with main, and why rebase leads to cleaner PRs and better code reviews.