Engineering High-Performance Systems & Autonomous Automation
I am a Software Engineer & Builder specializing in high-performance systems, automation, and Web3 environments. Powered by a strong algorithmic background, I build things that run fast, automate workflows, and solve real-world bottlenecks—from RPC load balancers to autonomous agents and trading bots.
TECHNICAL EXPERTISE
Core Competencies
Software Development
Building high-throughput microservices using Go, Rust, and TypeScript with a clean architecture and scalable design patterns.
Infrastructure Automation
Deploying secure, resilient cloud architecture using Terraform, Docker, and Kubernetes with GitOps CI/CD pipelines.
Architecture Trade-offs
Designing distributed databases, event-driven message brokers (Kafka/RabbitMQ), and cache topologies (Redis).
Technical Problem-Solving
Diagnosing complex system bottlenecks, memory leaks, and rate-limiting issues under heavy production loads.
SELECTED WORK
Featured Projects
Renyro — Local-First Workflow Automation
A local-first workflow automation platform that turns workflows into reusable Actions, portable Packs, and focused task-specific applications.
The Challenge
Automation stacks often depend on hosted control planes, external databases, multiple runtimes, and manual glue when a workflow needs to become a reusable application or agent capability.
The Solution
Built a single-binary Go platform backed by SQLite that combines a visual workflow engine, versioned Actions, Pack Format v1, an App Builder, and shared REST, CLI, MCP, webhook, and runner entry points.
CodeProof — Software Provenance Evidence
An evidence-first, local-first CLI for creating and independently verifying signed software provenance, proof chains, timestamps, and code fingerprints.
The Challenge
Software provenance claims are hard to audit when they rely on screenshots, mutable metadata, or unverifiable statements about who possessed which source state and when.
The Solution
Built a local-first CLI that seals committed source states, links exact-byte proof chains, signs fingerprints and provenance events, attaches Sigstore Rekor timestamp evidence, and exposes a bounded artifact-only verification surface.
A lightweight, zero-dependency SQLite-over-HTTP server in Go featuring WAL-mode concurrency and WebSockets subscriptions.
The Challenge
Accessing embedded SQLite databases concurrently across network boundaries is difficult and prone to locking issues, often forcing developers to migrate to heavy database engines.
The Solution
Created a Go-based gateway that wraps SQLite, providing REST endpoints for querying, safe WAL-mode concurrent read/write operations, and real-time push updates via WebSockets.
DomainEdge — Expired-Domain Decision Workstation
A private, local-first workstation for expired-domain discovery, evidence-backed paper decisions, risk guards, and rational maximum-bid analysis.
The Challenge
Expired-domain investing is noisy: acquisition price, resale probability, trademark risk, auction competition, and external appraisal signals can easily be mixed into opaque or impulsive decisions.
The Solution
Built a deterministic pipeline for GoDaddy inventory ingestion, PASS/REVIEW/REJECT filtering, domain classification, optional enrichment, trademark and health guards, expected-value modeling, traceable MAX BID, paper decisions, outcome evidence, and auction intelligence while keeping live acquisition locked.
A GitHub activity analysis product that reconstructs meaningful work units and turns collected engineering evidence into durable development briefings and stakeholder reports.
The Challenge
Commit counts and contribution graphs do not explain what engineering work actually happened, while AI-generated summaries can overstate impact when they are not tied back to collected evidence.
The Solution
Built an evidence-first pipeline that collects repositories, commits and pull requests, reconstructs deterministic work units and engineering mix, stores comparable snapshots, then uses DeepSeek only to explain observations grounded in the collected evidence ledger.
Tomato Toolbox — Offline Utility Suite
A privacy-oriented browser toolbox with dozens of utilities for developers, documents, images, finance, converters, productivity, and everyday tasks.
The Challenge
Many small online utilities require uploading files or sensitive input to third-party servers, while users often need a fast tool for one-off conversions and calculations without installing dedicated software.
The Solution
Built a bilingual offline-first toolbox that performs processing in the browser and combines 30 utilities across developer tools, image and PDF processing, text, finance, converters, productivity, and health calculations.
A high-performance smart routing gateway designed to balance JSON-RPC traffic across multiple blockchain nodes.
The Challenge
Querying public blockchain nodes is slow, expensive, and subject to aggressive rate limits, resulting in degraded app performance.
The Solution
Built a Go-based load balancer with a dynamic partition-routing algorithm and Redis-backed caching that automatically switches to the healthiest, lowest-latency node.
An ultra-lightweight, high-performance Serverless Edge Router in pure Go. Run untrusted user functions in sandboxed WebAssembly (WASM) containers via wazero.
The Challenge
Running untrusted user-submitted custom edge functions safely on servers usually requires heavy virtualization, slow cold-starts, or massive overhead.
The Solution
Built a lightweight serverless router in Go that runs custom scripts compiled to WebAssembly. Uses wazero to isolate execution in secure, zero-overhead WASM sandboxes with atomic hot-reloads.
Instant local file sharing & clipboard synchronization between PC & mobile devices over LAN with zero app installs, built in Go.
The Challenge
Sharing text or files between PCs and mobile phones usually requires complex cloud uploads, third-party apps, or messaging client spamming.
The Solution
Developed a lightweight local-first server in Go that leverages WebRTC and WebSockets to enable secure, direct device-to-device transfers through any standard browser.
A lightweight, local-first AI coding agent CLI in Go that performs safe, atomic search-and-replace code modifications using DeepSeek/OpenAI.
The Challenge
Large AI coding assistants are often heavy, require IDE installations, and can make erratic, untracked changes across files without safety gates.
The Solution
Built a fast Go CLI tool that interacts with LLMs to perform atomic search-and-replace operations with diff views and validation steps directly in the terminal.
A high-performance Go CLI tool that creates thousands of unique video variants with modified binary structures and unique MD5 hashes in milliseconds using direct MP4 atom parsing and mmap.
The Challenge
Generating variations of video files for multi-account publishing usually requires fully re-encoding the video stream, which consumes massive CPU/GPU resources, takes minutes per file, and generates excessive I/O overhead.
The Solution
Developed a Go engine that manipulates MP4 binary atoms directly (updating indices in stco/stsz boxes), uses Windows memory mapping (mmap) for zero-copy resource sharing, and injects random padding and audio timestamp jitters to generate unique MD5 hashes instantly without re-encoding.
An event-driven microservices dashboard and worker for automatically detecting and buying undervalued NFTs on Monad EVM networks.
The Challenge
Manual NFT sniping is slow and error-prone, while script-based bots lack control planes, logging, and secure transaction-signing mechanics.
The Solution
Built a Web Dashboard with Fastify (NodeJS) and Redis/BullMQ processing queues. Integrates Metamask for non-custodial signing, and monitors transaction receipts using native JSON-RPC.
An automation tool that crawls invoice data from wholesale pharmacy APIs and converts it to standardized VNPT warehouse-entry formats.
The Challenge
Wholesale medical imports require manual inventory entry into VNPT Pharmacy systems, which is highly repetitive, slow, and prone to typing errors.
The Solution
Built a Python utility using Playwright to bypass login gates and capture API response payloads, automatically mapped SKUs and fields, and generated validated VNPT Excel sheets.
TECHNICAL JOURNAL
Recent Articles
Confidential NFTs: Implementing Private Ownership via FHE
A deep dive into Zama fhEVM and the Dual Ownership Model to preserve privacy of Real-World Asset (RWA) holders on-chain.
Designing an Event-Driven Web3 Bot: Fastify, BullMQ, and MetaMask
Architecting a robust, non-custodial NFT sniper bot with real-time WebSocket dashboard and distributed job queues.
Building a Pure-Go Serverless WASM Runtime with Wazero
How to execute untrusted user code safely at the edge using WebAssembly sandboxes in Go with zero CGO dependencies.