I build private product systems where product design, platform architecture, data governance, security, delivery, and AI-assisted execution are treated as one coordinated delivery system.
flowchart LR
Intent["Product intent\nmarket, domain, UX"] --> Surfaces["Product surfaces\npublic web, admin ops, commerce"]
Surfaces --> Contracts["Typed contracts\nREST, GraphQL, DTOs"]
Contracts --> Core["Platform core\nRust services, PostgreSQL"]
Core --> Data["Data plane\nmaps, search, media, ledgers"]
Data --> Ops["Operations\nobservability, QA, deployment"]
Ops --> Intent
Security["Security + governance\nauth, RBAC, audit"] -. guards .-> Surfaces
Security -. guards .-> Core
AI["AI delivery system\nplans, tasks, agent handoffs"] -. accelerates .-> Contracts
AI -. accelerates .-> Ops
Current work centers on a private production system. I keep the public description at the architecture level: domain ownership, API boundaries, data behavior, privilege separation, and the evidence needed to operate changes safely.
mindmap
root(Architecture work)
Domain ownership
Canonical content identity
Lifecycle and moderation states
Reputation and audit ledgers
Public versus administrative authority
Contract boundaries
REST for protocol and data-plane reads
GraphQL for composed experience views
Generated clients and DTOs
Contract smoke tests
Data behavior
Viewport-scoped map reads
Approximate location policy
Search and cache read models
Migration and index discipline
Privilege model
Role-scoped capabilities
Admin-origin separation
Step-up verification
Non-enumerating responses
Operability
Structured diagnostics
Request correlation
Failure evidence
Deployment rollback path
Current architecture tracks: contract design, domain-service boundaries, map read-model behavior, role-scoped governance, provider isolation, observability events, and repeatable verification.
Open-source pieces from my own operating environment: remote workstation reachability, OTP handoff, session display guards, Android debugging protection, storage governance, device repair, monitoring utilities, and workstation configuration. They are small, practical systems built around recoverability, long-session comfort, and explicit operator control.
Native macOS tool for keeping a plugged-in MacBook reachable while the lid is closed.
Swift · macOS · pmset · RustDesk · SSH workstation mode otp-bridge
iPhone SMS OTP handoff for Windows through a private ntfy topic and paste-only clipboard delivery.
C# · Windows tray · iOS Shortcuts · ntfy · Credential Manager
Windows tray utility that disables HDR during RustDesk remote sessions and restores it afterward.
C# · Windows tray · RustDesk · HDR session guard
Root-only Android screen guard for long USB debugging sessions.
Kotlin · Android · Jetpack Compose · root tooling samsung-t-series-console
Windows-native fix and safe-eject console for Samsung T-series portable SSDs.
PowerShell · portable SSD repair · safe eject
Codex Skills kit for safe Windows 11 C-drive cleanup, storage migration, and cache governance.
Python · Codex Skills · Windows storage governance clarity_lazyvim
Accessible LazyVim configuration focused on readability, contrast, and long-session comfort.
Lua · LazyVim · public template · editor environment
Shell and Zsh configuration files for a portable, recoverable command-line setup.
Shell · Zsh · configuration · development environment pi-monitor
Raspberry Pi website monitoring with RGB LED status and a small web interface.
Python · Raspberry Pi · monitoring · hardware status
TypeScript
Next.js
React
Tailwind CSS
Framer Motion
TanStack Query
Vue
Mapbox
C#
.NET
Windows
Windows Tray
Credential Manager
iOS Shortcuts
ntfy
Swift
macOS
pmset
RustDesk
SSH
Kotlin
Android
Jetpack Compose
Material 3
ADB
Root tooling
Python
Rust
Axum
Tokio
PostgreSQL
SQLx
OpenAPI
GraphQL
Redis
SQLite
WebAuthn
Docker
Vercel
Railway
Cloudflare R2
Shopify
GitHub Actions
Sentry
PostHog
NDJSON
Playwright
Vitest
Hurl
Checksums
Release ZIPs
FFmpeg
Bun
uv
Codex Skills
MCP
Shell
Zsh
PowerShell
Lua
C++
Neovim
LazyVim
Raspberry Pi
Rime
Plot twist: none of the above matters. Just learn Vibe Coding.
mindmap
root(Technical focus)
Product architecture
Domain modeling
Canonical objects
Public and admin surfaces
Operational workflows
Frontend platform
Next.js React TypeScript
SSR RSC SEO
Mapbox WebGL
Accessibility and motion budgets
Backend platform
Rust Axum Tokio
SQLx PostgreSQL migrations
OpenAPI Hurl contracts
GraphQL experience boundary
Windows utilities
CSharp dotnet tray apps
Credential Manager storage
HDR and remote session guards
OTP clipboard handoff
macOS utilities
Swift native apps
pmset power policies
Closed-lid workstation mode
RustDesk SSH Codex sessions
Android utilities
Kotlin Jetpack Compose
Material 3 interface
ADB and root shell probes
Screen protection services
Data systems
Map data plane
Cache keys and ETags
Search vectors and indexes
Audit and reputation ledgers
Governance
RBAC and WebAuthn
Step-up verification
Admin surface separation
Non-enumerating responses
Delivery and evidence
Vercel Railway Docker
Sentry PostHog NDJSON
Vitest Playwright Rust tests
AI-readable diagnostics
Automation
Codex workflows
PM PLAN TASK documents
Vibe Coding Skills
GitHub CLI and PowerShell
uv and reproducible tools
MCP connected workflows
Workstation
Neovim LazyVim Lua
Zsh shell tooling
Rime input workflow
Recoverable setup
Storage repair consoles
Raspberry Pi monitors
| Product | Architecture | Delivery |
|---|---|---|
| Own the product, domain model, public/admin split, and operational rules as one system. | Typed contracts, auditable data flows, permission boundaries, and observable failure evidence. | AI-assisted execution backed by PM plans, tests, diagnostics, and durable handoff artifacts. |
readable systems · operable environments · research-grade workflows
Product architecture, typed platforms, DevOps observability, media/data pipelines, and AI-assisted execution.
"Economics has always maintained that wealth emerges solely from production and services, and never originates from distribution."
Frank X.