Three engagements, and what stayed behind.

A new ERP went live and the analytics platform behind it started running hot. The question on the table was how much more capacity to buy. Nobody could say which workloads were using what, because model rebuilds, batch loads, and report queries all shared one lane and collided freely.

I read the query history for the week either side of the go-live and attributed every hour of compute to a workload and an owner. One family of models accounted for more than a third of the increase in development. In test the driver was reporting reruns rather than builds, so the two environments needed different fixes.

The recommendation was operational: separate lanes for builds, loads, and reports, a freeze on new scheduled models until approved, and the worst overlap windows broken up. Buying capacity stayed on the list as a fallback.

↳ What stayed behind: the attribution queries as a playbook anyone on the team can rerun, and a runbook for the next time the numbers creep.

A federal efficiency standard put a penalty-and-credit balance on every vehicle sold. The figure that would go to the regulator was produced by a warehouse model, and checked against a spreadsheet one person had built and one person understood. The check worked and nobody else could run it.

I wrote the spreadsheet down as a specification, then as a test suite: every rule the analyst applied by hand became an assertion that runs against the warehouse and fails loudly when the two disagree. The suite bakes into a notebook on the platform, so it runs where the data is and needs nobody’s laptop.

User acceptance ran off the same suite. The test register is generated from it, the daily status update is generated from it, and sign-off pointed at a run.

↳ What stayed behind: the suite, the register it produces, a self-service reporting layer over the verified models, and a handover the support team runs without me.

The platform team had good models and no end-to-end test. To see whether a change worked you rebuilt against live data, and the rebuild needed schemas dropped and recreated, and one engineer held the access to do that. Every pull request queued behind his calendar.

I refactored the seeds and snapshots so a build could run from committed fixtures. Updating a seed refreshed the whole chain, on anyone’s branch, with nobody’s elevated access. The test that had lived in one person’s permissions became a step in the pipeline.

It saved hours per change, and the team stopped waiting on one desk for the work to move.

↳ What stayed behind: the fixture-driven build, the data products it now gates, and a testing framework the team extends without me.