Selected Work

Problem

Our C++ library for customer hardware had severe latency issues — customers couldn't use the software at all. I was tasked to investigate and fix the performance bottleneck.

Constraints

• ▸ Customers couldn't use the software due to severe latency
• ▸ Root cause was hidden in complex request handling paths
• ▸ Required deep profiling without disrupting production traffic

Solution

I used perf to profile the hot paths during live requests, generated flamegraphs, and traced the problem to JSON serialization in the request handling loop. Verbose logging on every JSON operation made it worse. I disabled the unnecessary logging via a config toggle as a first step. I then participated in the design discussion and helped drive the effort to phase out JSON entirely through a complete architecture redesign for dynamic payload creation. I self-taught the SOME/IP protocol from specs to ensure the new approach was spec-compliant.

Outcome

• ▸ Removing verbose logging alone improved some request calls by 80%. The full architecture redesign eliminated the bottleneck long-term, restoring full functionality for customers.
• ▸ 80% latency improvement

Problem

Remote teams were developing software for an embedded Linux hardware system. Each developer set up their own environment manually, leading to inconsistencies and slow onboarding. Enable the team to develop and test reliably without physical hardware, regardless of local setup.

Constraints

• ▸ Remote teams needed exact hardware environment replication
• ▸ Manual environment setup led to inconsistencies and slow onboarding
• ▸ Team skepticism toward local-first Docker approach

Solution

I proactively created a Dockerfile that replicated the exact hardware environment — including VLAN setup and networking configuration — matching production precisely. I had to convince a skeptical team member who preferred pushing images to a remote service, arguing for a simpler local-first approach.

Outcome

• ▸ Setup time reduced from hours to under an hour. Remote teams could run and test the full system without physical hardware. Onboarding new engineers became significantly faster.

Problem

A customer needed a robust, event-driven finite state machine for industrial IoT devices. The existing C-based approach (built on the QP framework) wasn't robust or memory-safe enough for their requirements. Design and implement a finite state machine framework that the customer could use for their specific systems.

Constraints

• ▸ Existing C-based approach wasn't memory-safe enough for industrial IoT
• ▸ Framework needed to be generic enough for customer to adapt to any system
• ▸ Required modern C++ features — templates, RAII, smart pointers

Solution

I chose C++ over C for memory safety and designed the entire framework — including event handler registration, state transition logic, and example implementations — so the customer could adapt it to any set of states, transitions, and event handlers. I learned C++ features (templates, RAII, smart pointers) to implement a dynamic event-driven FSM that wouldn't rely on the C-style void pointer shortcuts.

Outcome

• ▸ The customer built on top of the framework for their customer-facing products. The FSM provided a robust, memory-safe foundation for their industrial IoT systems.

Problem

A startup fashion retailer wanted to use e-paper price tags for shelf markdowns instead of manual paper tags. We had partial knowledge of the APDU commands needed, but not the exact image format the proprietary device expected. Figure out how to generate an e-ink compatible image and send raw data over APDU to the proprietary e-ink display, as part of an R&D project.

Constraints

• ▸ Proprietary e-ink display protocol with unknown image format
• ▸ No documentation available — had to reverse engineer the format
• ▸ Part of R&D project with tight exploration timeline

Solution

I reverse engineered the image format through extensive trial and error and documentation research. The protocol required a specific "binnng" process where data had to be sent in a particular way. I used my prior experience with NFC and APDU protocols to build an Expo app on Android that generated the correct image and transmitted it to the display. I worked solo given my specific background.

Outcome

• ▸ I built a fully functional label creation app that could generate e-ink compatible images and send them to the proprietary display. The R&D project explored whether e-paper price tags were viable for the retailer.

Problem

When designing the collaborative wiki, the initial approach of edit locking could lock users out of pages and introduce wait times. I wanted to avoid that friction from a user experience perspective. Design a collaborative editing system that allowed multiple users to edit simultaneously without lock conflicts.

Constraints

• ▸ Edit locking would create friction for concurrent users
• ▸ Required efficient full-text search alongside CRDT editing state
• ▸ Needed real-time sync with sub-second convergence across sessions

Solution

I chose CRDT (Conflict-free Replicated Data Types) via the y_ex library (Rust-backed) to handle concurrent edits without requiring locks. I designed the PostgreSQL schema with dual storage — a CRDT field for editing and a raw text field to enable fast full-text search and future AI moderation capabilities. I used Elixir's Registry for O(1) lookup to map page IDs to EditLock GenServer PIDs, allowing efficient process address resolution without bottlenecks.

Outcome

• ▸ The CRDT approach eliminated edit lock conflicts entirely. Multiple users can edit simultaneously, with the dual storage schema enabling both efficient search and AI integration without requiring a separate search engine.

Problem

AI-assisted development often produced outputs misaligned with my vision — requiring many iterations to reach satisfaction. I was doing "vibe coding" without deterministic guardrails to keep AI on track. Create a development framework that would add determinism to agentic coding, ensuring AI worked on the right problems and stayed aligned with the intended outcome.

Constraints

• ▸ AI-assisted development produced outputs misaligned with intended outcomes
• ▸ Vibe-coding lacked deterministic guardrails to keep AI on track
• ▸ Needed a repeatable framework applicable across any project or language

Solution

I designed a Spec-Driven Development (SDD) framework that combines Acceptance Test Driven Development, Test Driven Development, and Test Driven Agentic Development. The framework provides structured specifications before coding, creating checkpoints that surface misalignments and inefficiencies before they become problems.

Outcome

• ▸ Using SDD, I caught inefficiencies and misalignment early across multiple projects. The framework improved my agentic coding efficiency by reducing wasted iterations and keeping AI output aligned with goals.

Problem

I built the Divergent Tabletop community website using Astro. The community includes a vent and support group where trigger warnings and spoilers needed appropriate handling. Ensure the website met accessibility standards and had proper content warnings for sensitive discussions.

Constraints

• ▸ Community includes sensitive content requiring trigger warnings
• ▸ Needed WCAG compliance with full keyboard navigation
• ▸ Had to handle edge cases like invisible Unicode characters in content

Solution

I built the website with WCAG compliance as a target, ensuring keyboard-based navigation and readability. I created a "read more" forced-scroll tool for trigger warnings and spoilers — handling edge cases like invisible Unicode characters that display differently than their character count suggests. I optimized for Lighthouse performance to ensure fast load times.

Outcome

• ▸ The website met accessibility standards with keyboard navigation support. The trigger warning tool was implemented for the community's sensitive content needs.