Notes from My Sabbatical
There is a distinct kind of humility that comes with working on old structures. Lately, I have been spending my time dealing with the irregular geometry of our farmhouse kitchen. The room itself dates back to the 1800s, and I am in the middle of building a completely new kitchen island from scratch, while simultaneously restoring a vintage 1950s gas stove to replace a modern, out-of-place appliance.
When you strip a space like that back to its original framing, or when you try to retrofit a heavy, under-cabinet fireclay sink into a layout built over a century ago, you quickly realize you are in a silent conversation with whoever stood there before you. You are dealing with their logic, their shortcuts, and their triumphs.
In both carpentry and technology, we often suffer from a collective obsession with the brand new. We want the clean slate, the greenfield project, and the latest framework. But the real world is rarely a clean slate. The real world is a complex network of legacy systems that are already running, already making money, or already keeping the weather off your head.
The truest test of an operations leader isn’t whether you can build something pretty from scratch. It is whether you can accurately analyze the bones of an existing system and restore it without pulling the whole house down around you.
The Appraising Decade
Before I returned to enterprise technology at forty-two, I spent a decade working in commercial real estate appraisal. My job was essentially structural and financial archaeology. I spent years analyzing the literal bones of complex physical systems: tracking income streams, calculating capitalization rates, and evaluating the structural integrity of massive commercial assets.
That era beat a concept into me that I call Integrity-Based Analysis.
When you are appraising a property, you learn to look completely past the fresh coat of paint or the staging furniture. You go straight to the basement to inspect the foundation walls. You audit the historical ledger data. You learn to ask the hard, unfashionable questions: Does the core structure actually support the load it is carrying right now? Does the verified data prove its long-term viability?
When I made my pivot back to software, I discovered that an enterprise code repository is exactly like a historical commercial building. The documentation might be outdated, the original architects are usually long gone, and there are almost always a few sketchy structural choices hiding behind the walls.
Enter the Software Archaeologist
This is exactly where standard generative AI tools and junior developers tend to hit a wall.
AI is brilliant at generating raw syntax out of thin air, but it is notoriously terrible at archaeology. An LLM cannot look at a massive, multi-tenant software ecosystem that has been running continuously since 2014 and intuitively understand why a specific, seemingly bizarre database query path was implemented. It doesn’t understand the historical context, the legacy API dependencies, or the human compromises that shaped the codebase.
To safely modernize a monolith, you have to be a software archaeologist first. Before you rewrite a single line of code, you have to profile the environment. You need to understand the structural load points: where the database writes are bottlenecking, how data flows across third-party extensions, and where the system is fragile under peak usage.
If you lack the patience to analyze the bones before you swing the sledgehammer, your modernization project will inevitably trigger total site failure.
Constructing the Structural Shoring
When engineers are tasked with restoring a historic building, the first thing they do is install temporary structural shoring. They support the load-bearing beams before they touch the foundation.
In software engineering, our structural shoring is built out of automated testing pipelines and strict regression tracking.
During my time scaling platforms at places like GigaOM and StellarWP, process improvement wasn’t about enforcing arbitrary rules. It was about creating safety nets for the team. By architecting robust automated testing pipelines using PHPUnit and continuous integration environments via Jenkins or GitHub Actions, we built digital shoring.
That shoring gave our developers the psychological safety to refactor legacy code, optimize core plugin engines, and push the platform forward without the constant, paralyzing fear of breaking backward compatibility for hundreds of thousands of active production environments.
Honoring the Existing Framework
Whether I am adjusting a cut list for a butcher block countertop, mapping out the tight dimensions for our custom canning center, or designing a functional, dish rack to integrate cleanly into an 1800s passthrough, my approach to systemic health remains completely identical.
We must respect the structures that got us here while building the durable, custom extensions required to take us where we need to go next. True innovation is rarely about tearing everything down; it is about the careful, deliberate orchestration of structural evolution.
The shoring is in place, the dimensions are verified, and the bones are sound.
I am looking for my next mission leading teams who appreciate the value of resilient architecture, deep operational observation, and systems built for the long haul. Let’s look past the surface level, pull up the floorboards, and build something durable together.