Blog Roadmap
Upcoming Blog Posts
These are the topics I’m planning to write about. They’re drawn from my project experience, lessons learned, and things that don’t fit neatly into project documentation.
Technical Deep Dives
Building PhantomArbiter: Solana Arbitrage at Millisecond Scale
- Real-time WebSocket streaming from DEX feeds
- Multi-strategy detection (Raydium, Jupiter, Orca, Meteora)
- How latency kills profit: why MEV matters
- JITO bundle protection and MEV-aware ordering
- Python + Rust for latency-critical code
- Lessons from 400+ test trades
Why it matters: Shows how to think about real-time systems where milliseconds determine success or failure.
Architecture Patterns That Actually Scale: rpgCore’s ECS Design
- What is Entity-Component-System and why game developers love it
- Why ECS beats inheritance hierarchies
- Cross-language architecture: Python core + C# frontend + Godot integration
- Testing ECS systems without a game running
- Scaling from “one game” to “any game”
- How constraints (no external dependencies) forced elegant design
Why it matters: ECS is underused outside games, but it solves real architectural problems in data-heavy systems.
TurboShells: Full-Stack Real-Time Web Architecture
- WebSocket sync between FastAPI backend and React frontend
- Bridging the gap between server-side physics and client-side rendering
- Hexagonal architecture in a game context
- Why your data model matters more than your framework
- Deploying to free tiers without cutting corners
Why it matters: Shows that you don’t need expensive infrastructure to build production-grade systems.
Lessons Learned
1000+ Commits Last Year: What Shipping Taught Me
- Frequency beats perfection
- Small commits = easier debugging = better code review
- The projects that got the most commits were also the most solid
- Why “shipping is a feature”
- Tools that made iteration faster
- Mistakes made (and how to avoid them)
Why it matters: Practical insights for engineers who want to ship more.
Why 5000+ Users Keep Using My Chrome Extensions
- Understanding user friction before building solutions
- Version 1 vs Version 2: what changed adoption
- How to balance automation with user control
- Handling edge cases that you didn’t anticipate
- Maintaining extensions across platform updates
- Building for trust, not convenience
Why it matters: Extensions are small but they teach you about user behavior and retention.
The Hidden Cost of “Quick Hacks” (And Why I Don’t Ship Them)
- Technical debt compounds, but so does quality
- Why maintenance time matters more than build time
- Six-month test: will this code survive without me?
- Choosing speed or sustainability
- How constraints forced me to make better decisions
Why it matters: Most writing on this topic is theoretical. This is the practical reality.
Domain Knowledge
Call Center Automation: What I Learned From 2000+ Users
- The rhythm of call center work (not random—seasonal, predictable)
- Where automation fails (and why)
- The difference between lazy automation and thoughtful automation
- Real economics: how much time does this save per week?
- Building tools people actually want to use
- Domain knowledge as a superpower
Why it matters: Call centers are complex systems. Most engineers don’t understand the constraints.
Solana for Engineers (Not Traders)
- How Solana actually works (beyond the hype)
- RPCs, indexing, and why latency matters
- Understanding MEV and front-running
- Building on Solana without getting rugged
- Python libraries for Solana development
- When Solana makes sense (and when it doesn’t)
Why it matters: Too much Solana writing is for traders. This is for people building systems.
Game Design Philosophy: Why Constraints Make Better Games
- Tetris, Roguelikes, and minimal game design
- Procedural generation vs hand-crafted content
- The economics of game development (indie constraints)
- Player psychology: why pacing matters
- Edge cases in games (and how players find them)
- Balancing systems without data
Why it matters: Game design principles apply to UI/UX and systems design everywhere.
Career & Philosophy
Why I Left Traditional Work for Systems Building
- The gap between “good at my job” and “fulfilled”
- Building vs maintaining
- Entrepreneurship vs employment (trade-offs)
- How constraints shaped my thinking
- What “shipping at scale” means to me
- The role of chance vs skill
Why it matters: Not everyone needs to follow the same path. This is mine.
Reading Influences: How Douglas Adams, Pratchett, and Rowling Made Me Better at Code
- Lateral thinking (Adams) applied to technical problems
- Systems thinking (Pratchett) in architecture
- Constraint appreciation (Salvatore, games) in design
- World-building (Rowling) as a metaphor for systems design
- Why literature matters for engineers
Why it matters: Great thinking comes from everywhere, not just CS papers.
Quick Takes (Short Posts)
- Why Python + Rust is my preferred stack
- The underrated power of simple SQLite databases
- How to read a GitHub repo (quickly)
- Tools that make development 10x faster
- Debugging strategies that actually work
- The case against microservices (usually)
- Why documentation is code
Writing Schedule
I’m currently prioritizing:
- Solana/Trading topics (PhantomArbiter deep-dive)
- Architecture topics (ECS, hexagonal design)
- Lessons from shipped projects (what actually works)
- Domain knowledge (call centers, game dev)
Most posts will be 2,000-4,000 words. I’d rather write fewer, deeper posts than flood the blog with shallow takes.
Suggest a Topic
If there’s something you’d like me to write about—either from my projects or general engineering topics—reach out. The best blog posts come from questions people actually have.