The Vision

In high-volume digital marketing, the dialer is the engine. But most managers are driving blind, relying on static reports that are out-of-date by the time they are read.

The Friction (Manual Patch)

The standard workflow involved manual CSV exports, Excel “voodoo,” and re-uploading leads. This created a latency gap—by the time we realized a lead source was underperforming, we had already burned the budget.

The Systemic Fix (The Insight Lens)

I built a custom observation layer injected directly into the browser via a Chrome Extension.

The Vision

Speed is everything in DeFi, but rigidity is a death sentence. A pure-Rust bot is fast but a nightmare to iterate on. A pure-Python bot is agile but loses the race to the block.

The Systemic Fix

I engineered a Hybrid FFI Bridge.

1. The Rust Core: Handles the “Hard Work”—WebSocket connections, memory-safe transaction signing, and packet serialization.
2. The Python Strategy: Communicates with the Rust core via a lightweight interface, allowing me to swap trading logic without re-compiling the binary.

The ROI

By decoupling the Execution from the Intelligence, I achieved the best of both worlds: the safety of a compiled systems language and the “Fresh Context” agility of a scripting language.

The Vision

Learning to build the foundation before the house. The transition from a discrete project to a generalized toolkit.

Why I built an engine to solve my own friction

The shift from RogueAsteroid (Specific) to rpgCore (General) was born out of a realization: I was re-writing movement, collision, and state logic for every small game idea.

The Systemic Fix

I abstracted these common patterns into rpgCore, a modular toolkit built on a simplified Entity-Component-System (ECS) pattern in Python.

There is a specific kind of magic that occurs exactly once in a coder’s life. For me, it was the moment I realized my “Pong” paddle wasn’t moving because I told it to—it was moving because it knew where the ball was going. That first taste of artificial agency is the high we’ve been chasing ever since.

Fast forward through years of professional IT consulting and architectural deep-dives, and that childhood impulse finally found its form in what eventually became OperatorGame. But the path wasn’t a straight line; it was a series of transmutations.

rpgCore taught me that architectural clarity is worth more than raw performance when prototyping complex systems. Here’s how we bridged Python, C#, and Rust into a cohesive game engine.

The Problem Statement

Most game engines are monolithic. Godot is great at rendering, but scripting in C# alone feels limiting. I wanted to explore: what if the engine was polyglot by design?

• Python for high-level game logic (fast to prototype, mature libraries)
• C#/Godot for rendering and visual debugging
• Rust for performance-critical calculations

The catch: making three languages cooperate without spaghetti code.

I built PhantomArbiter to detect and execute arbitrage on Solana. After 400 live trades across 3 months, I lost $4. Here’s what went wrong—and why the technology actually worked.

The Setup

System: Detect price divergence across Solana DEXes (Jupiter, Raydium, Orca, Meteora). Execute buy-low / sell-high atomically via JITO bundles (MEV protection).

Capital: $500 initial. Modest, but real money.

Timeline: 3 months, 400 completed trades.

Result: -$4.23 net.

Why It Failed (Technically)

RPC Latency Kills Speed

Solana blocks come every 400ms. My system sees an arbitrage opportunity, but by the time I submit the bundle, 2-3 blocks have passed. Price has already moved. The spread that looked profitable is now break-even or negative.

When I started as a Data Administrator, I inherited a mess: spreadsheets, manual data entry, no integration between systems. So I built a pipeline to automate 60% of my responsibilities. Here’s what I learned.

The Starting State

The problem: Contact center operations drowning in manual work.

• Lead import: CSV files dropped into email → manually copy into CRM → validate → assign
• Data cleaning: Leads with bad emails, duplicates, missing fields → hours per week in cleanup
• Enrichment: Missing company info, job titles → manual lookups
• Integration: Three separate systems with no data sync (CRM, email, call logs)
• Reporting: Hand-assembled spreadsheets for weekly management review

Time spent: 30 hours per week on data plumbing. 10 hours on actual admin work.

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.