Engineering high-assurance systems—from industrial edge devices to enterprise web.

Launch Terminal System >> Built with Rust & WebAssembly.

I don't just build frontends; I engineer complete systems. My focus is on Reliability Engineering—creating applications that look great on the client side (Next.js/React) while remaining bulletproof on the server side. Whether it's high-frequency blockchain forensics, cross-platform desktop apps, or business-critical booking platforms, I build software designed to fail gracefully and recover instantly.

My flagship portfolio demonstrates systems engineering across three pillars of reliability:

Guardian One Web-Demo — All three pillars in one interactive story.

A story-driven demonstration unifying the Reliability Triad into a single coherent narrative.

• Live Demo: guardian-one-web-demo.vercel.app
• Concept: Industrial edge security—Python/Docker vs WASM side-by-side.
• Flow: Problem → Hardware → Demo → Proof (guided learning experience)
• Stack: Leptos, Pyodide (real Python execution), WASI 0.2.
• Features: Real CVE citations, IEC 62443 zones, 2oo3 TMR voting, live attack simulations.
• 🍓 Hardware Preview: Browser simulation of a physical demo running on a real Siemens S7-1200 PLC with a 3-node Raspberry Pi cluster. Hardware version coming soon.

Project: ICS Guardian Capability-based security demo: WASI 0.2 data diode for industrial control systems.

• Live Demo: vanguard-ics-guardian.vercel.app
• Concept: Sandbox untrusted sensor drivers—allow reads, block exfiltration.
• Stack: Rust (cargo-component), Leptos, WASI 0.2, JavaScript host (JCO).
• Security: 17 integration tests verifying all 4 security states.
• Highlight: 14.7KB WASM component vs 500MB+ Docker containers.
• 🍓 Hardware Demo: See Guardian One Web-Demo for browser preview. Physical hardware demo coming soon.

Project: Protocol Gateway Sandbox ⭐ FLAGSHIP Safe legacy protocol translation via WASM sandboxing—Modbus TCP → MQTT with crash containment.

• Live Demo: protocol-gateway-sandbox.vercel.app
• Concept: Malformed Modbus crashes the sandbox, not the gateway. ~7ms recovery (measured).
• Stack: Rust (nom parser), Leptos, WASI 0.2, JavaScript host (JCO).
• Reliability: 2oo3 TMR voting with real WASM measurements—SIL 3 patterns.
• Security: Dual-terminal demo with 4 attack vectors + "Run All" chaos mode.
• Highlight: IEC 62443 attack surface minimization—only 2 of 40+ function codes implemented.
• 🍓 Hardware Demo: See Guardian One Web-Demo for browser preview. Physical hardware demo coming soon.

Project: Raft Consensus Cluster Distributed consensus in the browser via WASI 0.2—same Rust binary runs in browser AND on Raspberry Pi.

• Live Demo: raft-consensus.vercel.app
• Concept: Leader election, log replication, network partitions—all visualized live.
• Stack: Rust, WASI 0.2, Leptos, IndexedDB, BroadcastChannel.
• Reliability: Chaos controls to kill nodes and watch the cluster self-heal.
• Advanced: PreVote protocol implementation (Raft Thesis Section 9.6) prevents disruptive servers.
• Highlight: 120+ tests covering elections, replication, and fault scenarios.
• 🍓 Hardware Demo: See Guardian One Web-Demo for browser preview. Physical 3-node Raspberry Pi cluster coming soon.

Project: The Kennel Platform A Zero-Liability booking and guest management platform for luxury pet facilities.

• Concept: Digital Identity ("Pawsports") & Biometric Access Control.
• Stack: Next.js 14, Rust (Axum), FIDO2/WebAuthn, SQLite.
• Scale: ~20,000 lines frontend + ~3,500 lines Rust backend.
• Security: 10/10 integration tests passing, IDOR protection, rate limiting.

Metafrontier Current Engagement.

• Role: Ecosystem Security & Technical Support.
• Focus: Managing operational security for a high-value user base, triaging technical incidents, and mitigating social engineering threats.

CyberVerse (Co-Founder & Lead Engineer) Legacy Project - Active Ecosystem.

• Role: Co-Founder / Core Developer.
• Achievement: Built the platform from the ground up (0 to 1), scaling it to a live, self-sustaining ecosystem.
• Tech: MongoDB, Vanilla JS, Web3 Integration.

I operate across the entire stack, from pixel-perfect UI to system-level runtime control.

Core Systems	Web & Backend	Data & Security

• Deep Runtime Knowledge: I understand the JavaScript runtime at a low level (ESM vs CJS, Event Loop, Bundling). I specialize in making legacy modules work within modern, strict frameworks like Next.js.

• Zero-Liability Design: I prioritize risk reduction. I leverage hardware security (FIDO2) and architectural air-gaps to ensure that toxic data (Credit Cards/PII) never touches the application database.

• Capability-Based Security: I design systems where untrusted code runs in sandboxes that can only access explicitly granted capabilities. Deny by default, grant by exception.

• Crash Containment: Untrusted parsers run in WASM sandboxes. A buffer overflow kills the sandbox—not the host. Sub-millisecond recovery, zero data loss.

• Hitless Failover: 2oo3 TMR voting ensures continuous operation during faults. WASM's microsecond instantiation enables software failover without frame loss.

• Real Measurements, Not Marketing: When I claim "<0.1ms rebuild," I provide performance.now() timings (5-sample averaged) in the live demo. Evidence over assertions.

• Incident Response: Mitigating live threats and phishing vectors in the Metafrontier ecosystem and associated Solana protocols.
• Transaction Analysis: Specialized in tracing diverted funds and analyzing smart contract interactions on Solana/EVM.

👉 Explore Full Portfolio (Terminal Mode)