Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
Remembering my father’s final six months: the small goodbyes, the long journey home, and the water chestnuts he saved for me every year.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Remembering my father’s final six months: the small goodbyes, the long journey home, and the water chestnuts he saved for me every year.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Remembering my father’s final six months: the small goodbyes, the long journey home, and the water chestnuts he saved for me every year.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
Remembering my father’s final six months: the small goodbyes, the long journey home, and the water chestnuts he saved for me every year.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
A practical guide to configuring OpenClaw with multiple AI providers — Azure AI Platform (GPT-4.1 and GPT-5), GitHub Copilot’s free Claude Sonnet 4.6, MiniMax as a budget fallback, and zero-cost local models via Ollama — so you’re never paying more than you need to.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
Remembering my father’s final six months: the small goodbyes, the long journey home, and the water chestnuts he saved for me every year.
Published:
First day at a new job in Melbourne. After 20 years calling Perth home, the mix of sadness, excitement, and quiet gratitude that comes with starting over in your 50s — and why a short separation is the foundation for a long reunion.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
A jump arc is just a handful of numbers, but they’re the numbers that decide whether a platformer feels right. One game got its numbers from a 20-year-old design decision I never wrote down; the other got them by decompiling a Spine skeleton and an obfuscated state machine.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
55 hand-authored levels and 356 decompiled scenes are two completely different level-design problems. One needed documentation that could never drift from the shipped JSON; the other needed a map from a marketing-facing level number to a buried binary scene ID.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
A side project that started as ‘port an old Mario clone to a modern Android engine’ turned into something stranger: decompiling three abandoned mobile platformers byte by byte and rebuilding their game design from the evidence, with an AI assistant doing most of the archaeology.
Published:
One game’s enemies follow a rule I wrote down myself: jump on top to defeat, touch the side and it hurts. The other game’s 316 actor resources follow rules nobody wrote down for me — they had to be pulled out of an obfuscated rule VM, action by numbered action.
Published:
Six years ago I started building an AI-agent platform for Android and never finished it. Last week, newly settled in Melbourne and with some time back, I picked it up again — this time with Claude Code and GitHub Copilot doing the heavy lifting while I stayed in charge of direction. It changed how much a side project can actually get done.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
Two very different engine problems in one project: refactoring a working Mario port into a reusable platformer toolkit without breaking it, and designing a compiler/VM pair that can execute a decompiled game’s own scripted behavior safely.
Published:
A spec-first look at Engine 2: the data-driven rule VM I’m designing to run three decompiled Android platformers’ original scene and actor logic, how it slots into the Guidebee Game Engine, and why the implementation hasn’t started yet — on purpose.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
🎉 Happy New Year 2026! Quote service evolution continues: splitting the quote-service into 3 specialized services (local, external, aggregator) for a total of 5 microservices with dual shared memory for ultra-fast IPC, batch streaming, and 100× faster oracle validation.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
After extended testing of our circular arb engine and a bot-tracing investigation that revealed a competitor likely running co-located infrastructure, it’s becoming clear: circular arbitrage on Solana seems very difficult to achieve with home settings — and the infrastructure investment required to compete changes the economics entirely.
Published:
A candid look at how I used AI tools — Claude Code, GitHub Copilot, and multiple frontier LLMs — as genuine development partners to build a production-grade Solana HFT trading system. What actually works, what doesn’t, and what it means for how software gets built.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
Data-driven token config cleanup: disabled 9 LSTs that contributed zero arb signals across 373,000+ events, kept the 5 that matter, and expanded monitoring to 6 extra token pairs (BONK, WIF, JUP, RAY, ORCA, PYTH) via a new enabled flag system. Results to follow.
Published:
Final quality assessment of the Solana quote & scanner pipeline: 9.4M quotes across 11 test sessions, a 106.4-hour uninterrupted run with zero errors, 100% oracle coverage, and structured arbitrage signals detected from Orca Whirlpool concentrated liquidity pools across multiple DEXes.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
How I set up OpenClaw — an AI agent gateway — to monitor and control my Solana HFT Docker services via Telegram, with strict security isolation so the AI bot can never touch private keys or wallet secrets.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Happy Chinese New Year! Comprehensive gRPC quote service validation delivers a 9.3/10 system health score — zero critical deviations across 1,001 quotes, 100% oracle price coverage, and 99.9% arbitrage match rate. The system is production ready.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Comprehensive upgrade to the quote service ecosystem: Local Quote Service gains intelligent pool quality management with oracle validation and dynamic refresh priorities, External Quote Service integrates Jupiter/DFlow/OKX APIs, and the new Quote Aggregator Service merges both sources with confidence scoring for optimal trade execution.
Published:
Pool Discovery Service undergoes major refactoring after discovering critical liquidity calculation bugs. Architecture simplified to focus solely on discovery, comprehensive test suite validates 716 unique pools across 13 DEXes, and extensive token pair support beyond LST tokens. Production metrics confirm improvements with proper liquidity tracking and accurate pool counting.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
🎄 Merry Christmas! Planning a comprehensive rewrite of quote-service with clean architecture principles: 85% code reduction, 20x faster quotes, 4x better test coverage, and dramatically improved maintainability. Why we’re rebuilding the foundation for long-term success.
Published:
Deep dive into quote-service architecture: Go-powered quote engine with sub-10ms responses, gRPC streaming, NATS event publishing, Redis crash recovery, and 99.99% availability. The critical data layer powering our HFT pipeline.
Published:
FlatBuffers migration infrastructure is complete. All 8 services migrated to zero-copy serialization with 6-stream NATS architecture. Added system-manager (kill switch) and system-auditor (P&L tracking). Most services are stubs, but the foundation is solid - ready for strategy implementation.
Published:
Documentation consolidation for FlatBuffers migration: From 13 scattered docs to 1 authoritative guide. Why early-stage architecture changes are critical for HFT systems, even though time-consuming. Migration still in progress - and it’s worth every minute.
Published:
Building a production-ready HFT pipeline: 4-stage architecture with 6-stream NATS separation, FlatBuffers zero-copy serialization for 21% latency reduction, and comprehensive kill switch safety controls for sub-100ms quote-to-execution.
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Deep dive into gRPC streaming architecture for real-time quote distribution: achieving sub-20ms latency, handling 1000+ quotes/second, and preparing for high-frequency arbitrage with optimized token pair quote streaming.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Added comprehensive metrics and distributed tracing to the quote-service, created a detailed Grafana performance dashboard, and drafted a complete Kubernetes migration plan. Plus, a special birthday celebration for my son Harry as he embarks on his university journey.
Published:
Migrated from deprecated Promtail to Grafana Alloy and upgraded to the complete Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for unified observability. Updated the Events Dashboard with real-time NATS event monitoring, preparing for a potential future migration to Grafana Cloud.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Five years of Solana development and three working trading prototypes inform the production system. This post provides context on that research journey, the lessons learned, and why the challenge itself is valuable regardless of outcome.
Published:
Three major improvements today: renamed event-preparer to system-initializer to reflect expanded capabilities, added production-grade LST token support with oracle price feeds and deviation detection, and implemented market event publishing for real-time trading data distribution.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
Pool Discovery Service reaches production milestone with triangular arbitrage support (45 token pairs), completing the Quote Service Rewrite architecture. Observability reveals surprising market insights: SOL/USDT has 278B liquidity (vs SOL/USDC 226B), and forward/reverse pool discovery yields asymmetric results.
Published:
A systematic validation campaign for the planner (strategy service) layer: subscribing to live arb events, converting to Jupiter swap instructions, merging two-hop route instructions into a single atomic transaction, simulation, and on-chain execution — including confirmed DEX compatibility, token ledger chaining, and the Jito bundle rate-limit wall we hit.
Published:
How we fixed silent enrichment failures in the pool-discovery service: decoding Solscan’s XOR-encoded binary API responses, implementing a preflight URL pattern for cross-origin session sharing, and replacing a fallback enricher with an alternating design that keeps both data sources continuously exercised.
Published:
OpenClaw isn’t just for monitoring trading bots — it’s a general-purpose AI agent gateway. I used it with Claude Code to rapidly build a China A-share stock data pipeline and TradingView-compatible charting service, then wired OpenClaw to analyse stocks and send chart summaries straight to Telegram.
Published:
How we built a headless Chromium microservice with puppeteer-extra-plugin-stealth and residential proxy support to reliably fetch data from bot-protected DeFi APIs — and the non-obvious design decisions that made it work.
Published:
Deep dive into the TypeScript Scanner Service architecture - the arbitrage detection engine that processes gRPC quote streams, detects profitable opportunities, and publishes FlatBuffers events. Plus: reflections on two months of AI-assisted development and thoughts on the future of programming.
Published:
Major milestone achieved: infrastructure reaches 85% completion with production-ready quote services. Project assessment validates 70-75% feasibility for $1k/month target. Ready to shift focus to arbitrage scanner, planner, and executor development in TypeScript as prototypes for future Rust implementation.
Published:
Comprehensive architectural assessment of a production-grade Solana HFT system. Event-driven design, FlatBuffers zero-copy serialization, polyglot microservices, and 6-stream NATS architecture achieve sub-500ms execution with 87% CPU savings. Grade: A (93/100).
Published:
Building production infrastructure: Dynamic oracle-based reverse quotes for accurate arbitrage detection, scanner framework optimization with 80% code reduction, and extensible patterns for DCA, limit orders, and liquidation monitoring.
Published:
Implementing a high-performance arbitrage scanner using gRPC streaming to achieve 85x faster quote delivery and sub-30ms detection latency. Moving from prototype to production with architectural improvements.
Published:
Published market events to NATS JetStream in the quote-service with comprehensive Grafana monitoring, and created a TypeScript scanner-service stub as the foundation for real-time trading opportunity detection. The TypeScript version will be implemented first, with a high-performance Rust version planned for later.
Published:
Implementing comprehensive observability across Go, Rust, and TypeScript services with unified logging, metrics, and tracing. Added event-preparer and notification-service, integrated quote-service monitoring with Grafana dashboards.
Published:
Implementing a unified event system across Rust, Go, and TypeScript for the Solana trading system. Includes market data events, system health monitoring, kill switches, and arbitrage opportunities - all communicating via NATS JetStream.
Published:
Starting a journey to build a production-grade High-Frequency Trading (HFT) system on Solana. Currently have working arbitrage bots (~1.7s execution), aiming for sub-500ms execution with local pool math, Shredstream integration, and flash loans.
Published:
A tour of Engine 2, the game-independent rule language and VM inside the Guidebee Game Engine: its four-layer architecture, how a rule is compiled and executed, what the specification pins down, and why game behavior belongs in data instead of code.
Published:
Deep dive into the pool-discovery-service architecture: WebSocket-first pool updates, hybrid three-tier discovery strategy, and the intelligent RPC proxy enabling reliable connections to Solana RPC providers.
Published:
How we achieved 35% latency reduction and 87% CPU savings by migrating from JSON to FlatBuffers and evolving from priority-based to event-type NATS streams in our Solana HFT trading system.