Technical insights and observations on software development, digital craft, and technological evolution.
Expect content that balances technical insight with measured reflection, seasoned with just the right amount of humour. These ideas and observations refused to stay quietly in mind, now shared to spark meaningful discussions and fresh perspectives.2025 (10)
Reproducible build pipelines, calmer velocity metrics, and unapologetic debt triage defined 2025—ambitious launches stayed trustworthy for teams and clients alike.2024 (5)
Lightweight dnsmasq tweaks, tmux muscle memory, and a renewed obsession with simple tooling made 2024 about clearing friction so experiments actually shipped.2023 (3)
Grounding habits around uptime math, disciplined dotfiles, and dependable SSH pathways kept 2023 focused on humble craft that scales when incidents inevitably strike.All (18)
View all blog posts across all years
15 min read
AWS sub-accounts: isolating resources with Organizations
Most teams dump client resources into their main AWS account, creating an administrative nightmare when projects end or security issues arise. AWS Organizations sub-accounts provide hard security boundaries that separate resources, limit blast radius from incidents, and make cleanup trivial—yet many developers avoid them, assuming the setup complexity outweighs the benefits.
11 min read
The architecture autopsy: when 'we'll refactor later' becomes 'we need a complete rewrite'
Early architectural decisions compound over time, creating irreversible constraints that transform minor technical debt into catastrophic system failures. Understanding how seemingly innocent choices cascade into complete rewrites reveals why future-proofing architecture requires balancing immediate needs with long-term reversibility.
19 min read
The symptom-fix trap: Why patching consequences breeds chaos
In the relentless pressure to ship features and fix bugs quickly, development teams fall into a destructive pattern of treating symptoms rather than root causes. This reactive approach creates cascading technical debt, multiplies maintenance costs, and transforms codebases into brittle systems that break under the weight of accumulated shortcuts.
9 min read
The 2038 problem: when time runs out
At exactly 03:14:07 UTC on January 19, 2038, a significant portion of the world's computing infrastructure will experience temporal catastrophe. Unlike Y2K, this isn't a formatting problem - it's mathematics meets physics, and we can't patch the fundamental laws of binary arithmetic.
20 min read
The velocity trap: when speed metrics destroy long-term performance
Velocity metrics were meant to help teams predict and improve, but they have become weapons of productivity theatre that incentivise gaming the system while destroying actual productivity. Understanding how story points, velocity tracking, and sprint metrics create perverse incentives is essential for building truly effective development teams.
18 min read
Sprint overcommitment: the quality tax nobody measures
Three features in parallel, each "nearly done". The authentication refactor sits at 85% complete. The payment integration passed initial testing. The dashboard redesign awaits final review. None will ship this sprint—all will introduce bugs next sprint. Research shows teams planning above 70% capacity experience 60% more defects whilst delivering 40% less actual value.
12 min read
Technical debt triage: making strategic compromises
Simple CSV export: one day estimated, three weeks actual. User data spread across seven tables with inconsistent types—strings, epochs, ISO 8601 timestamps. Technical debt's real cost isn't messy code; it's velocity degradation. Features take weeks instead of days. Developers spend 17 hours weekly on maintenance from accumulated debt.
10 min read
Environment reproducibility: Docker vs. Nix vs. Vagrant
Production threw segmentation faults in unchanged code. Four hours revealed the cause: Node.js 18.16.0 versus 18.17.1—a patch version difference in native addon handling exposing a memory corruption issue. Environment drift creates space for bugs to hide. Docker, Nix, and Vagrant solve reproducibility at different levels with distinct trade-offs.
9 min read
Reproducible development environments: the Nix approach
Dozens of Go microservices in Docker, almost a dozen Node.js UI applications, PostgreSQL, Redis. Extensive setup process. Docker Desktop, Go 1.21 specifically, Node.js 18 specifically, PostgreSQL 14, build tools differing between macOS and Linux. When it breaks, debugging requires understanding which layer failed. Developers spend 10% of working time fighting environment issues.
10 min read
The hidden cost of free tooling: when open source becomes technical debt
Adding file compression should have taken a day. Three packages needed different versions of the same streaming library. Three days of dependency archaeology, GitHub issue spelunking, and version juggling later, we manually patched node_modules with a post-install script. Open source is free to download but expensive to maintain.
10 min read
Avoiding overkill: embracing simplicity
A contact form implemented with React, Redux, Webpack, TypeScript, and elaborate CI/CD pipelines—2.3MB production bundle for three fields and a submit button. Two days to set up the development environment. Thirty-five minutes to change placeholder text. This is overengineering: enterprise solutions applied to problems that need HTML and a server script.
10 min read
Terminal multiplexing: beyond the basics
Network drops during critical database migrations. SSH connections terminate mid-deployment. Terminal crashes destroy hours of workspace setup. tmux decouples your terminal interface from persistent sessions that continue running independently—network failures become irrelevant interruptions rather than catastrophic losses, whilst organised workspaces survive crashes and reconnections.
10 min read
SSH keys in 1Password: eliminating the file juggling ritual
SSH keys scattered across machines create a familiar nightmare—copying files between systems, remembering which key lives where, and the inevitable moment when you need to connect from a new laptop without access to your carefully managed ~/.ssh directory. 1Password's SSH agent transforms this by keeping encrypted keys available everywhere whilst ensuring private keys never touch disk outside the vault.
10 min read
Turbocharge development: the magic of SSH port forwarding
Security policies block database ports. Firewalls prevent external connections. Remote services remain inaccessible except through carefully controlled channels. SSH port forwarding creates encrypted tunnels that make distant services appear local—you connect to localhost whilst traffic routes securely to remote resources, maintaining security boundaries without compromising workflow efficiency.
9 min read
Streamlining local development with Dnsmasq
Testing on localhost hides entire categories of bugs—cookie scope issues, CORS policies, authentication flows that behave differently on real domains. These problems surface after deployment, when fixing them costs hours instead of minutes. Dnsmasq eliminates this gap by making local development behave like production, turning any custom domain into localhost whilst preserving domain-based security policies.
7 min read
SSH dotfiles: unlocking efficiency
Managing dozens of SSH connections means remembering complex hostnames, multiple keys, and elaborate commands you copy from text files. The .ssh/config file transforms this chaos into memorable aliases that map mental shortcuts to complete configurations, reducing cognitive load so you can focus on actual work rather than SSH incantations.
11 min read
Dotfiles: why and how
Working on someone else's machine feels like writing with their hands—common commands fail, shortcuts vanish, and everything feels wrong. Dotfiles transform this by capturing your accumulated workflow optimisation in version-controlled configuration files, turning any terminal into your terminal within minutes rather than days of manual reconfiguration.
10 min read
Downtime of uptime percentages, deciphering the impact
Understanding the real-world implications of uptime percentages is paramount for businesses and consumers alike. What might seem like minor decimal differences in uptime guarantees can translate to significant variations in service availability, impacting operations, customer experience, and bottom lines.
Topics for the properly obsessed
1password (1)
Technical insights and practical approaches to 1password in modern software development.architecture (4)
System design principles and architectural patterns that shape resilient, maintainable software solutions.automation (6)
Systematic approaches to eliminating repetitive tasks through intelligent scripting and workflow optimization.aws (1)
Technical insights and practical approaches to aws in modern software development.configuration (3)
Configuration management strategies that bring order to chaos across development environments and production systems.debugging (1)
Methodical approaches to hunting bugs and understanding why systems behave in mysteriously broken ways.devops (2)
Cultural practices and technical solutions bridging the gap between development agility and operational stability.docker (1)
Container-based development and deployment strategies for consistent environments across the entire software lifecycle.git (1)
Version control mastery and collaborative workflows that transform chaotic code changes into organized development history.infrastructure (3)
Foundation-level systems and architectural decisions that determine the scalability and reliability of digital services.linux (1)
Deep dives into Linux systems, from kernel behavior to command-line wizardry that powers modern computing.monitoring (1)
Observability practices and monitoring strategies that transform silent failures into actionable intelligence.networking (2)
Network engineering insights exploring the intricate dance of packets, protocols, and connectivity solutions.nix (1)
Functional package management and reproducible systems that bring mathematical precision to dependency chaos.patterns (3)
Design patterns and anti-patterns that separate maintainable codebases from technical debt graveyards.performance (1)
Performance optimization techniques that transform sluggish systems into responsive experiences users actually enjoy.productivity (4)
Workflow optimizations and tool mastery that multiply developer effectiveness without sacrificing code quality.quality (6)
Software quality principles and practices that distinguish robust systems from those held together by hope.security (6)
Security engineering practices that protect systems from threats both obvious and obscure.ssh (3)
Secure shell mastery and remote access patterns that turn distributed systems into a unified workspace.standards (1)
Coding standards and conventions that transform individual preferences into collective consistency.terminal (1)
Command-line excellence and terminal workflow mastery that transforms text interfaces into productivity powerhouses.testing (2)
Test engineering strategies that catch bugs before users do and ensure code behaves as intended.