Every project is the foundation for the next.

While most people were only buying crypto, I needed to know how it worked under the hood. So I did what I always do: I started building. In the early Web3 years I helped found a set of crypto-infrastructure ventures - a privacy coin, a mining operation, an exchange, and a pool - and I took a university blockchain program in parallel to make sure my theory matched my code. Consensus mechanisms, cryptographic primitives, systems that simply had to stay up. That was my real entry into this world: not as a trader, but as an engineer.

I fell down the infrastructure rabbit hole and helped scale a mining operation into a real business. I designed the whole stack: custom cooling enclosures for maximum performance, datacenter layout, and the backend - e-commerce, inventory, and the operational systems that kept it running. That deep hardware obsession eventually put me in the room for institutional-scale hardware deals, where I ran the technical due diligence.

The real test was never scaling - it was keeping systems alive under conditions that were never supposed to happen. During long, severe network disruptions that cut us off from the outside world, letting the machines sit idle was not an option.

So we re-architected to keep running straight through the outage: customizing low-level protocols for forwarding and aggregation, and engineering a bridge around the failure. In a zero-trust environment, effectively cut off from the global grid, the systems kept producing. That period taught me more about resilience than any ordinary year of uptime ever could.

After years of building the shovels, I wanted to dig. I became obsessed with algorithmic trading - tearing apart and optimizing hundreds of strategies across every scripting language the platforms offered, figuring out what actually works and why.

But the existing tools frustrated me. They were slow, repainting was everywhere, and nobody offered honest tick-level fidelity. So I built my own engine from scratch: a real-time, event-driven tick processor written entirely in Go, engineered to eliminate repainting at the root and run across every major exchange. I designed a small declarative language so strategies could be written cleanly and executed at native speed, then wired it into a professional charting frontend to serve as a high-performance trading terminal.

The architecture is composable. You build atomic components - a trailing stop, a volatility filter, a regime detector - and snap them together into a complete strategy. You can inspect every metric step by step, profile the whole run, and move an idea through a strict pipeline: backtest, demo, paper, live. The entire system turns on one uncompromising principle: don't lose money.

Building did not stop there. Along the way I wrote smart contracts, built agent infrastructure and AI memory systems, and automated dozens of workflows - each repository a rabbit hole I had to explore.

Today I operate as a one-person engineering department. I maintain dozens of live services on infrastructure I own end to end: data pipelines, monitoring, bots, AI agents, mail and DNS, reverse proxies, and web apps - all containerized, with CI/CD on my own build servers. No DevOps team. No SRE department. Just one engineer who treats uptime as a personal obligation.

From compiling my first privacy coin to writing a Go trading engine, every project becomes the foundation for the next.

I'm a builder who thrives when I own the entire stack, from the first line of code to production. If you move fast and care about what is actually under the hood, let's talk.