What actually broke, and what actually fixed it.
No client names, ever — the work is real and dated, the companies aren't identified. Every entry here is a specific problem, the actual root cause once it was found, and the fix. Nothing here is a generic "an AI made a mistake" story; those aren't interesting and they aren't the point. This is the boring, specific, verifiable kind of engineering writing.
A 16-point coverage swing came from sample spacing, not a drawing bug
A coverage-raster view built specifically to sanity-check the propagation engine turned up isolated "blocked" cells speckled through otherwise clear terrain, on a design that should have read as clean. The ray-sampling step size was set to max(terrain step, cell size) — 250m — while a rock rim that mattered to the link was only 240m wide. Whether a given ray intersected the rim came down to arbitrary sample placement relative to that 250m grid, not to the physical geometry. Re-running the identical design at 50m sample spacing changed reported coverage from 67% to 50.9%. The fix was tightening the sampling resolution and adding a check that flags any terrain feature narrower than the current sample step, so the next one doesn't get silently averaged away.
A sign error that zeroed out every reflection path the engine had ever computed
The analytic propagation engine's reflection-path formula computed the image-source crossing point as t = d / (d − r) instead of the correct t = d / (d + r). With the transmitter and receiver on the same side of a wall — the common case in an indoor or urban model — the wrong formula never landed inside the valid (0,1) range, so the reflection term was discarded as geometrically invalid on every single run. No error, no warning. The model had been quietly missing a whole class of propagation path since the formula was written. Fixed and regression-tested against a physically-based reference ray tracer: mean absolute error against the reference dropped from 2.56 dB to 0.94 dB.
A physical effect counted twice, and a performance wall that wasn't the hardware's fault
An engine audit found vegetation clutter loss being counted twice in the same path-loss calculation: once baked into diffraction geometry height, and again as a separate clutter-loss term, silently inflating total loss through tree cover on every affected link. The same audit found a terrain-profile function awaiting a call inside a per-cell loop, which meant a single large coverage run could issue up to four million sequential awaited calls for one transmitter. That had been assumed to be a hardware ceiling on how large an area could be computed at a given resolution; it was actually an architectural one, and fixing the loop structure removed it.
Two unrelated deploy-script bugs, stacked, and the one that almost hid the other
An Azure Key Vault smoke test reused a fixed secret name on every run. Key Vault's soft-delete reserves a deleted secret's name for 90 days, so every re-run after the first hit a permanent name collision once purge protection was turned on. Separately, in the same deploy script, Git Bash's MSYS2 path conversion was silently mangling every CLI argument that started with a forward slash — which is every Azure resource ID — so four separate role-assignment calls were failing without any visible error (they were wrapped for idempotency, which normally swallows exactly this kind of noise). That alone would have shipped a managed identity with zero permissions and no indication anything was wrong. It was only caught because one unguarded step in the same script hit a hard failure and stopped the whole run. Fixed with a unique probe-secret name per run and MSYS2_ARG_CONV_EXCL='*' to stop the path-mangling at the source.
Four "passing" end-to-end tests weren't testing the path a browser actually takes
A backend function handling every write in the system — intake, conflict resolution, contract signing — returned HTTP 405 to a browser's CORS preflight request, which silently killed the entire write path in production. Four separate live end-to-end tests had all passed and been signed off as evidence the feature worked. The tests all used a Node-based client library that never issues a CORS preflight request at all, so they were validating a stand-in for the real transport, not the transport a browser actually uses. The defect lived exactly in the gap between the test double and production, which is the kind of gap a green test suite can't see. Fixed, and it produced a new standing rule: a contract test against the deployed function that explicitly exercises the CORS preflight, run in the same pass that deploys it.
A silent default and a stale price table, both caught by reading, not by tooling
A database migration's alter default privileges clause meant every newly created table started out writable by default, so "append-only" was an unenforced opinion rather than a real guarantee. The same pattern recurred on three different tables over two days before it became a standing migration-checklist item instead of something to remember case by case. Separately, the pricing table used to meter AI billing was missing two newly released model variants, so every request against them was silently billed at the most expensive legacy rate instead of the correct, cheaper one. Neither of these threw an error. Both were caught by manually auditing the actual state against what was assumed, not by any automated check — which is itself the lesson: some classes of bug don't announce themselves, they just quietly cost money or quietly remove a guarantee you thought you had.
Three automation platforms, three hard requirements, each one found only after commitment
A client needed an automation platform that could also meet a partner institution's strict requirements around encrypted file transfer and key handling. Three separate platforms were each evaluated, committed to, and only then found unable to clear a requirement that should have been checked first: the first platform's negotiation with the partner's secure-transfer endpoint couldn't be completed and exposed no way to tune it; the on-premises replacement couldn't survive the client's own IT-managed security policy, which blocked the automation's own recovery mechanism, not just its configuration, and roughly four weeks of mitigation failed before that host was abandoned; and migrating off it to a cloud platform then broke a working encryption step, because that platform's sandboxed runtime couldn't execute the custom module the encryption depended on. Three platform-fit failures in sequence, each one invisible until the prior commitment had already been made. The lesson that came out of it, now a standing part of how these engagements start: the hard integration requirement gets proven against a real sandbox before a platform is chosen, not after.
An 11-day fault with two unrelated causes stacked on the same link
During commissioning of a distributed network rollout across dozens of remote sites, one link's connectivity fault took roughly 11 days to root-cause. The reason it took that long: there were two independent causes on the same link, not one. A field crew had changed a piece of equipment's configuration during physical installation, and, separately, equipment on the other end of that same link had reverted to a factory-reset state on its own. Either fault alone would have been a quick fix; stacked together, each one masked progress on diagnosing the other. Worth noting on its own terms: it was written up afterward as a deliberately blame-neutral joint lessons-learned document, specifically so the organizations on both ends of that link could review it together rather than argue about whose fault it was.