Introduction
Most organizations automate the wrong things. I find what should never have been manual, and remove it where it starts.
Before writing any code, I map what is actually happening: where work queues for the people doing it, what gets pushed into tribal knowledge, and what already shows up in tickets, alarms, and half-maintained runbooks. The outcome is friction removed at the source: tight where the stack needs proof, plain where people need to act, and written down where the next rotation should not depend on memory.
How I work
Framing Define the problem before the spend: vocabulary everyone can stress-test together, acceptance paths people can recognize, then the implementation worth defending.
Removal Strip manual work at the root instead of polishing recurring toil someone still has to own at odd hours.
Boundaries Design flows with explicit limits, failure modes, and ownership, not flows that quietly assume a human safety net. Keep coherence when load, ownership, and operating assumptions all shift at once.
Simplicity Prefer the smallest structure that still fits the real workflow, the seams you cannot pretend away, and what a stranger can reconstruct from the repo and docs in one afternoon.
Automation Target sustained work that should not depend on people, rather than one-off friction mistaken for a systemic fix.
Clarity Make intent legible in names, contracts, and runnable notes (not only in code) so reorgs, vendor swaps, and on-call rotation do not erase what mattered.
Now
Building systems around a recurring pattern: high-criticality platforms where structured data is ingested, validated, and stays consistent under continuous operation.
Working on identity and access across systems of different generations: authentication flows that must hold across boundaries never designed to work together.
Modernizing legacy systems without shutting them down: evolving architecture, data models, and integration layers while they remain in production.
Designing data flows and validation for large, structured inputs where correctness, traceability, and performance are obligations at the same time.
Exploring distributed consistency, long-running workflows, and cross-boundary transactions, plus metadata-led change in configuration and contracts before it hardens into ad hoc code paths.