Development Craft
Root-caused a silent whole-pipeline classification bug.
Every production document was being misclassified. I traced it back to a read-path mismatch between what the Python extraction pipeline produced and what the rules layer expected, then fixed it with a canonicalizing seam that holds up even when the model misassigns fields. (Medical Claim SaaS Platform, the reasoning service's read-path classification fix)
Found a CI gap that hid a payment-critical defect for five days.
A missing pytest marker was silently deselecting 20 golden tests. That masked a checkout defect. I fixed the underlying testing-infrastructure gap, not just the one test. (Medical Claim SaaS Platform, an internal engineering-lessons log entry)
Found and closed a traversal blind spot in a third-party SQL parser library (node-sql-parser, in TypeScript).
I reproduced the gap directly. Window specifications and DISTINCT ON clauses were invisible to the library's AST visitor. So I added a second, unconditional defense-in-depth sweep instead of trusting the library's documented API. (Payor Rate Data Platform, the platform's SQL guard module)
Inverted a security control from denylist to allowlist based on measurement, not intuition.
The existing denylist missed most of a dangerous function family. Postgres also exposes an SQL-injection-capable function that no static list could safely enumerate. I rebuilt the control around an allowlist with categorized function families, plus a test that asserts the two sets never overlap. (Payor Rate Data Platform, the platform's SQL guard module)
Identified and named a new class of bug specific to LLM-backed applications.
Every backend layer (resolver, access-control fence, audit log) was correct and had flipped state within seconds of an entitlement change. But the Claude API model kept asserting the stale fact because it anchored on its own prior conversation turns. That defect is invisible to the fence, the guard, every grant, and every test that asserts on PostgreSQL rows. (Payor Rate Data Platform, an entitlement-state incident writeup)
Wrote property-based regression coverage for a cross-cutting invariant.
Wrote a pytest test that checks, across the full state-by-plan-class matrix, that a regional rule can never make an outcome worse than a federal baseline. This protects the invariant permanently instead of just pinning individual cases. (Medical Claim SaaS Platform, the reasoning service's statutory decision-due test suite)
Built a custom PII/PHI scrubber and iterated it against real false positives.
Wrote a fail-closed, regex-based PHI scanner in Python. Then I tuned a curated allowlist after production data showed benign terms, like agency names and payer names, tripping it. (Medical Claim SaaS Platform, the reasoning service's PHI scanner)
Matched test-suite architecture to CI cost and signal tradeoffs.
Split the test suite into unit, integration (Docker-backed), compliance, and live-provider smoke suites. This let GitHub Actions run the cheap, deterministic majority on bare runners and save container-backed runs for tests that actually needed them. (Medical Claim SaaS Platform, the claims-processing service's test suite and CI configuration)
Built image supply-chain hygiene into CI.
Added per-service Docker image size budgets, a production-image import check to catch dev-only dependencies leaking into prod images, and vulnerability scans with Trivy on every build. (Medical Claim SaaS Platform, the claims-processing service's CI pipeline configuration)
Diagnosed an unrecoverable CI-only browser-automation flake.
Found that a test framework's form-fill call could leave React's internal value tracker out of sync with the DOM. That meant the same failing input could never be fixed just by retrying. (Medical Claim SaaS Platform, an internal engineering-lessons log entry)
Designed CI triggers around a GitHub Actions limitation.
I learned that GitHub Actions never reports status for a skipped, path-filtered required check, which would otherwise block pull requests forever. So I deliberately made the required cross-repo consistency check run unconditionally instead of path-filtered. (Medical Claim SaaS Platform, the claims-processing service's cross-repo consistency CI workflow)
Diagnosed a CI-cost defect down to a specific third-party GitHub Action's quantifier semantics.
A path filter meant to skip an expensive job on unrelated pull requests was firing on every one instead. Its exclusion line never worked either, because of how the underlying pattern-matcher combines patterns. I fixed it by re-deriving the filter as a positive enumeration, then pinned the fix with a test that compiles the GitHub Actions workflow file itself. (Payor Rate Data Platform, the web layer's CI eval-workflow configuration)
Root-caused a resource-leak class in query cancellation.
Measured that destroying a database client on cancel leaves the PostgreSQL backend connection permanently active, never idle in transaction. That meant a timeout-based reaper could never reclaim it. I fixed it by closing the read cursor instead of the connection. (Payor Rate Data Platform, the query-execution and cancellation layer)
Built cache-cost math directly from the Claude API's documented mechanics.
Derived a per-round tool-call cap from the Claude API's cache-lookback block limit, using an explicit inequality instead of picking a number empirically. (Payor Rate Data Platform, the chat engine's tool-call configuration)
Caught accessibility defects invisible to the full automated test suite.
Manual review found a fake aria-modal attribute, a silent success state with no live region, and a roving-tabindex bug, the kind of thing a click-driven test suite structurally cannot see. I used the findings to argue for accessibility-tree assertions as a first-class test category. (Payor Rate Data Platform, a manual accessibility review of the web product)