I build the systems that keep models running in production.

Nover generates images for creative teams. Every generation request flows through infrastructure I own end to end: an API gateway, a distributed job queue, an autoscaled GPU worker fleet, and global content delivery — all on AWS. The specifics stay under wraps until we launch; the responsibility doesn't.

Beyond serving, I run full fine-tunes of our proprietary diffusion models on rented H100s, and own the release infrastructure — including the pipeline that delivered our waitlist launch announcement, with throttling and resume capability built in.

A fault-tolerant task queue built on the Reliable Queue Pattern: at-least-once delivery through atomic Redis LMOVE operations, multi-tier priority queues, delayed scheduling via sorted sets, batch ingestion, and dead-letter queues for poison messages.

The interesting part is failure. A lease-based reaper watches for workers that died mid-task and atomically reclaims their work, and the whole system is instrumented with native Prometheus metrics. I validated it the only way that counts — automated chaos tests that kill workers at random while the queue is under load.

A streaming pipeline that watches BTC trade on two exchanges at once and spots the moments they disagree. WebSocket feeds from Coinbase and Binance land in Kafka; Flink tumbling windows align the two streams in time and compute the spread; an alerter pushes live notifications to Discord while a Streamlit dashboard charts spreads and alert history.

The system is decomposed into four services — producer, stream processor, alerter, dashboard — each independently deployable and orchestrated with Docker Compose, so any piece can fail or restart without taking down the pipeline.

A high-performance packet sniffer in modern C++. NetProbe captures live traffic through Npcap, performs deep inspection of TCP/IP headers, and extracts TLS SNI — so you can see which hosts a machine is talking to even when the payload is encrypted — rendering everything in a real-time Dear ImGui interface.

Packets arrive in bursts far faster than any UI can draw. The architecture is a multi-threaded producer–consumer pipeline using std::jthread: a capture thread feeds a lock-guarded buffer, parser workers drain it, and the render thread never blocks on the network.

Deep learning didn't appear from nowhere — a surprising amount of it is statistical mechanics wearing a different hat. This research project traces that lineage explicitly, with working code at every step: from the 2D Ising model through Hopfield networks toward Neural Network Gaussian Processes.

Phase 1 is a fully vectorized Ising simulation — the one running at the top of this page — that reproduces the critical temperature to within 0.05% of Onsager's exact solution. Phase 2 maps Ising dynamics onto Hopfield networks as learnable energy models, recovering 68% strict pattern recall at 25% corruption, with a full LaTeX write-up.