Product and system architecture
Clarify the domain, ownership, authority and lifecycle before UI complexity hardens around accidental implementation details.
Independent interactive systems studio · product engineering
Boutique product design for systems that need to be understood, felt and trusted.
I combine systems architecture, interaction design, prototyping and implementation for products where behavior matters as much as appearance. The work moves from domain models and experiments to polished interfaces, strict engineering boundaries and browser-level verification.
Selected work
A small set of active systems, shown in depth.
The portfolio is deliberately selective. Each flagship study shows a different kind of systems problem and the path from product intent through interaction design to architecture, verification and deployment.
Information modeling
Timeline
A local-first chronology and relationship workspace with a renderer-independent temporal projection layer and retained keyed scene. Overscan, interaction retention and commit-time reconciliation preserve identity and performance while timeline, graph and map views evolve toward a coordinated model.
Read case study
Media systems
Slipmat
A playback-first media system organized as domain contracts, deterministic planners and state machines, adapters and services, presentation models, then platform projections. Playback authority stays explicit across Jellyfin, local media, native processing and the interface.
Private · active product development Read case study
Procedural systems
Defend
A behavioral-parity modernization of a physics-driven strategy game. The historical Webpack/Babylon/Cannon build remains an executable reference while the active modernization lane isolates deterministic domain logic, worker and audio ownership, and renderer-independent contracts.
Read case study
Economic simulation
Lemonade
A deterministic economic simulation whose core is prohibited from depending on ambient time, randomness, browser state or rendering libraries. Three.js, Web Audio, storage and UI remain adapters, while fixed-seed certification makes balance and accounting reviewable.
Public · active development Read case studyActive lab
Smaller systems that test a specific idea hard.
These projects stay visible because their current architecture or interaction problem is distinctive, not because every active repository belongs on the front page.
Embedded input
QMK / Vial / Halcyon
An embedded input stack where firmware owns runtime semantics and persistence while typed Raw HID exposes capability-aware host configuration. Exact-target builds, resource reports, strict QMK lint and embedded anti-pattern checks make hardware constraints executable.
Simulation architectureFireOne
A deterministic submarine tactics simulation where the authoritative world, observations and AI knowledge remain separate. The product turns uncertainty itself into the main interaction model.
Configurable platforms
Booking
A configurable reservation platform built around a pure scheduling engine, replaceable persistence and explicit production transaction boundaries. Governance registries, SBOMs and provenance evidence are treated as part of the system architecture rather than release paperwork.
Knowledge systemsInvestigation Workbench
A provenance-aware local knowledge workspace that keeps source evidence, machine proposals, reviewed canonical knowledge and deterministic graph projections as distinct states.
Capabilities
A design studio with an engineering core.
The strongest engagements are systems with unusual state, timing, media, simulation, hardware or information-model constraints—places where interaction design and architecture cannot be separated.
Interaction and prototyping
Build working experiments early enough to test spatial behavior, timing, transitions, feedback and physical or media interaction.
Native web experiences
Use semantic HTML, modern CSS, View Transitions, Web Animations and progressive enhancement before adding runtime abstraction that the platform already provides.
Engineering and verification
Turn successful experiments into durable systems with strict types, deterministic tests, performance evidence, accessibility checks and CI-backed browser certification.
Approach
Explore freely. Promote evidence. Encode the result.
The studio process deliberately separates discovery from commitment. A fast experiment can stay cheap; a behavior only becomes architectural once there is enough evidence to protect it.
Model the problem
Map actors, constraints, states and failure modes. Make ownership explicit before selecting a presentation architecture.
Prototype the behavior
Use playable software, real media, real hardware and representative data to test the interaction rather than only describing it.
Harden what survives
Move proven behavior into types, tests, contracts, CI and documentation so later iteration can remain fast without losing the model.
Professional thread
Design practice informs the way I engineer software.
My background connects graphic design, multimedia production and teaching with public-service software, large planning interfaces and systems engineering. Code is a design material: a way to clarify relationships, test assumptions and shape interaction.
The through-line is not a particular framework. It is the ability to move between visual composition, user observation, state modeling, implementation, performance analysis and verification without treating those disciplines as separate handoffs.
Read the professional experience narrative