System design judge
Built a system-design judge with queue-backed Go workers and per-submission container orchestration.
Ownership, in practice.
The systems I helped research and build, the decisions behind them, and what I learned along the way.
Microsoft/Excel
Making formula remediation safe to ship.
I owned formula remediation, helping people make changes while preserving the meaning of their work.
Delivered
Reliable repairs, with clear checks and visibility into what changed.
- The problem
- Repairing a formula must preserve its meaning and the work around it, including changes made by other people.
- My responsibility
- I owned formula remediation and its progression, including investigation, implementation, regression tests and operational monitoring.
- The decision
- I reduced repeated work while keeping validation central to the repair process.
- The outcome
- Delivered formula remediation and addressed reliability issues as it reached users, with checks to catch regressions.
Checking the change, not trusting the agent.
I owned evaluation for automated changes and handled collaborative editing scenarios, keeping shared work consistent as people and agents make edits.
Delivered
Changes evaluated in context, with safeguards for collaboration and recovery.
- The problem
- An automated edit can look right in isolation and still conflict with shared work. Evaluation must account for people editing together and for changes that need to be reversed.
- My responsibility
- I owned evaluation orchestration and handled collaborative editing scenarios, working with specialists to keep shared work consistent.
- The decision
- I evaluated changes in the context of the wider document and handled collaborative editing scenarios as part of that work.
- The outcome
- Delivered evaluation workflows with safeguards for collaborative editing, failures and recovery.
Making test blind spots visible.
I built ways for teams to see which user journeys their tests cover and where important gaps remain.
Delivered
A clearer view of risk, helping teams decide what to test next.
- The problem
- An aggregate coverage number does not tell a team which user-facing operations remain untested.
- My responsibility
- I built the measurement approach and worked with partner teams to make the results useful for planning.
- The decision
- I connected test coverage to user-facing behavior so teams could investigate gaps beyond an aggregate percentage.
- The outcome
- Made gaps easier to investigate and supported cross-team decisions about where to improve testing.
Finding the cost of repeated work.
Investigated avoidable work between systems and turned the finding into guidance others could use.
Delivered
One targeted improvement and a clearer way to investigate similar issues.
- The problem
- Individually reasonable choices can add up to unnecessary work when systems interact.
- My responsibility
- I investigated the pattern, worked with specialists and delivered a targeted improvement in one affected operation.
- The decision
- I made the responsibilities between systems explicit and removed work that did not need to be repeated.
- The outcome
- Delivered one fix and identified other candidate operations for investigation. Broader cost savings were not yet established.
An expanding scope.
I build reliable client, automation and AI-assisted systems for Excel. The work changes; making complex behavior observable and safe does not.
Software Engineer I / Core systems
- Owned formula-language capabilities shared across product experiences.
- Improved responsiveness in slower, more demanding scenarios.
- Designed interactions that gave users faster feedback.
- Resolved long-standing rendering bugs in low-frequency, high-value scenarios.
- Built reusable interaction patterns shared across features.
Software Engineer I / Broader ownership
- Designed remediation workflows from detection through safe application.
- Built validation that preserved the meaning of users' work.
- Improved performance by reducing repeated work.
- Made reliability and test coverage easier to understand across teams.
- Investigated failures and strengthened safeguards for introducing changes.
Software Engineer II / Agentic systems
- Owned evaluation of automated changes, including collaborative editing scenarios.
- Built experiments and evaluations to understand the quality of AI-assisted work.
- Created reusable tools that reduced repeated investigation and validation effort.
- Helped teams see gaps in coverage of real user journeys.
- Mentored teammates and aligned partner teams around observable, reliable workflows.
Built to test an idea.
Personal explorations, separate from my professional work.
Cross-layer storage engine
Built a storage engine in C++, exposed it through Go, and connected it to a React query client to explore boundaries across storage, interop and UI.
Have a hard systems problem?
I am interested in the constraints, not just the technology.