Software Engineer

Reactive UI & ViewModel Architecture

The project had an established UI codebase with an opportunity to improve responsiveness and maintainability. I designed and implemented a new MVVM (Model-View-ViewModel) architecture centered around a ViewModelProxy. This system decoupled the UI view logic from the underlying game state. By using event streams and reactive bindings, the UI updated only when necessary, eliminating expensive polling loops (O(n) paths) and ensuring that the UI consistently reflected the current application state. This architectural shift reduced recurring UI defects by approximately 70% and significantly improved runtime performance.

High-Performance Input System

The game required precise control for its action-RPG elements on touch devices. I built a zero-allocation multi-touch input system from scratch. This system included:

• Gesture Recognition: Sophisticated detection of taps, swipes, and multi-touch gestures with confidence scoring.
• Dynamic Scheme Switching: Seamless transitions between touch, keyboard/mouse, and controller inputs.
• Predictable Behavior: The system was designed to be deterministic and robust under heavy load, ensuring consistent and accurate input handling during intense gameplay sequences.

Champion & Quest Systems

I was responsible for the end-to-end design and implementation of the Champion and Quest systems.

• Champion System: A flexible, policy-based rule engine that supported arbitrary logical complexity (AND/OR/NOT). This allowed designers to create complex character abilities and interactions without writing new code for every edge case.
• Quest System: Integrated with the Quantum deterministic simulation engine. I designed a system where "actors" and "events" in the deterministic simulation would signal the Unity presentation layer, allowing for complex quest progression tracking that was both secure (cheat-proof) and responsive.

Data Pipeline & Tooling

To support the design team's workflow, I created a robust Data Transformation Pipeline. This tool allowed designers to define game data in familiar formats like Microsoft Excel and Google Sheets. The pipeline then:

1. Parsed these files into intermediate C# representations.
2. Resolved References across different tables and sheets (e.g., a "Skill" sheet referencing a "Stat" sheet).
3. Serialized the validated data into highly optimized formats (JSON, ScriptableObjects, or Protocol Buffers) for runtime use. This system supported versioning and diffing, making it safe to iterate on game balance and content with predictable build stability.

Cultural & Architectural Leadership

Within a flat organizational structure, I took end-to-end ownership and introduced rigorous engineering practices, including:

• Requirement Gathering: Proactively identified stakeholders and translated broad product goals into concrete user stories and deliverables.
• Technical Documentation: Wrote extensive tech plans and used Mermaid diagrams to illustrate data flow and system interactions, ensuring that the codebase could be understood and maintained by others.
• Mentorship: Actively mentored junior engineers, helping them level up their C# skills and understanding of architectural patterns.

Custom MMO Engine & Physics

Unlike many modern projects that rely on off-the-shelf engines for backend logic, this project required a custom C# game engine built from first principles. I wrote the entire math and physics library, including:

• Shape Math: Intersection tests for circles, AABBs, and polygons.
• Collision System: Swept collision time tests to prevent tunneling and ensure precise entity interactions.
• Pathfinding: An A* pathfinding system with path smoothing, integrated into the movement system to handle dynamic obstacles.

Predictive Networking & Input

To provide a "Diablo-style" action-RPG experience in an MMO context, I implemented a sophisticated predictive input system.

• Client-Side Prediction: The client immediately simulated player input (movement, attacks) to provide instant feedback.
• Server Reconciliation: The server validated these inputs and sent authoritative state updates.
• Rollback & Correction: If the client and server diverged, the client would smoothly correct its state (rollback and replay) to match the server, masking latency artifacts.
• KCP Protocol: Utilized KCP (Reliable UDP) to achieve TCP-like reliability with UDP-level latency (30-40% faster than TCP).

Distributed Job Queue System

I architected the core gameplay loop around a distributed job queue backed by Redis.

• Architecture: Gameplay actions (e.g., opening a chest, crafting an item) were encapsulated as stateful "Jobs" stored as Redis hashes.
• Worker Pools: A horizontally scalable pool of worker services would pop jobs from the queue, execute their logic (often in multiple stages), and write the results back to Redis.
• Fault Tolerance: The system was transactional and durable, with automatic recovery and retry workflows. It supported complex entity-locking flows for consistent item transfers.

Bot Swarm & Load Testing

To validate the system's scalability, I built a "Bot Swarm" framework.

• Headless Clients: I developed lightweight, headless versions of the game client (stripped of Unity rendering) that could run game logic and AI.
• Orchestration: Scripts deployed thousands of these bots to AWS EC2 instances across various regions.
• Simulation: The bots executed realistic behavior patterns (moving, fighting, trading), stressing the networking, physics, and job queue systems to prove the architecture could handle thousands of concurrent users per zone.

Technical Culture & Cross-Team Collaboration

I operated across teams with different platform assumptions and aligned delivery around practical MMO/mobile requirements.

• Advocacy: I championed "offline-first" and "schema-agnostic" data collection practices and helped align them with broader analytics initiatives.
• Execution: I kept gameplay systems robust and production-ready by applying proven architectures and maintaining clear engineering standards.

End-to-End Data Collection & BI System

I researched, designed, and implemented a complete business intelligence system from scratch.

• Ingestion: Created client and server logging APIs that buffered data to local "chunk files" before uploading to S3. This ensured durability and supported offline play (data synced when connectivity returned).
• Pipeline: An AWS Lambda architecture triggered by S3 uploads. It fingerprinted events (for deduplication), indexed them for GDPR compliance, and streamed them to Elasticsearch (for real-time dev logs) and Redshift (for analytics).
• Schema Agnosticism: The system featured automatic schema detection. It analyzed incoming JSON payloads and dynamically updated Redis mappings to ingest new event types into Redshift without manual intervention.
• Redshift Architecture: Utilized a "Unified Fact Table" design for efficient ingestion and deduplication, which was then "materialized" into human-readable tables for analysis. This system scaled to billions of rows, with the game Meowmatch generating ~6 billion events alone.

Machine Learning Churn Prediction

To proactively retain users, I built a predictive analytics system.

• Feature Engineering: Aggregated session data, purchase history, and gameplay behaviors to create a rich feature set for each user.
• Modeling: Trained ensemble models (Random Forest, Gradient Boosting) to predict 7-day churn probability.
• Intervention: Users with elevated churn likelihood were automatically targeted with specific campaigns (e.g., "Gentle Nudge," "Premium Retention Offer") based on their value (LTV).
• Impact: Achieved 87% accuracy and a 3.2x ROI on retention campaigns.

A/B Testing Platform

I developed a comprehensive experimentation framework to operationalize evidence-based decisions.

• Cohort Management: A deterministic hashing system assigned users to control/treatment groups, ensuring consistent experiences.
• Dynamic Config: Integrated with the game's Lua OTA (Over-The-Air) update system to deliver different game balance, pricing, or UI configurations to different cohorts.
• Statistical Rigor: The system automatically calculated sample sizes and performed statistical significance testing, helping executives distinguish between random noise and real improvements.

DevOps & "Nuts" Backend Architecture

I modernized deployment workflows from FTP-based releases to fully automated delivery by:

• Automation: Implementing Jenkins and Git for one-click deployments and automated rollbacks.
• Infrastructure as Code: Managing AWS resources (EC2, DynamoDB) via scripts, including auto-scaling policies that adjusted capacity based on weekend/weekday traffic patterns.
• "Nuts" Library: I wrote the core Node.js library ("Nuts") that powered the backend services. It provided standard patterns for AWS interaction, distributed job queues, and the "Worker Pool" architecture used to horizontally scale gameplay logic.

Executive Education & Culture

Beyond code, I played a pivotal role in shaping the company's business strategy. I educated the executive team on statistical concepts (median vs. average, confidence intervals) and fostered a data-driven culture where decisions were backed by empirical evidence rather than intuition.

Real-Time Multiplayer on Mobile

At Z2Live, I worked at the forefront of mobile gaming, implementing real-time multiplayer experiences on 3G/4G networks. This involved:

• Latency Compensation: Implementing techniques to optimize gameplay responsiveness across variable mobile network latency.
• Bandwidth Optimization: Compressing data packets and optimizing synchronization frequencies to minimize data usage and prevent congestion.
• Reliability: Designing protocols that maintained session continuity through packet loss and temporary disconnections.

Distributed Systems & Backend

I leveraged Node.js and MongoDB to build the backend infrastructure supporting these games.

• Matchmaking: I built distributed matchmaking services that grouped players into sessions. This required efficient querying of player pools to find suitable opponents based on skill rating (ELO-like systems) and network proximity.
• Scalability: The systems were designed to scale horizontally to support the rapid growth of the mobile player base.

Polyglot Development

The role required versatility across the entire mobile technology stack. I wrote:

• C++: For high-performance shared game logic and engine code.
• Objective-C: For native iOS integration and platform-specific networking.
• Java: For Android platform support.
• Node.js: For server-side game logic and API services.

AAA Console Development

My tenure at Snowblind Studios (later acquired by Warner Bros) was my entry into the professional game industry. I worked on Lord of the Rings: War in the North, a complex action-RPG with a heavy emphasis on cooperative multiplayer.

• Engine Work: I worked directly in the C++ engine, implementing gameplay features and optimizing low-level systems. This required a deep understanding of memory management and processor architecture (e.g., the PS3's cell processor quirks).
• Networking: The game featured 3-player online co-op, which required robust network synchronization for combat, inventory, and quest progress. I contributed to the networking layer that made this possible.

Content Pipeline & Tools

A significant part of my role involved supporting the content team (artists and designers).

• Pipeline Tools: I developed tools to process assets (models, textures, animations) and convert them into engine-ready formats. Efficient pipelines were essential for keeping build times low and allowing the team to iterate quickly.
• Build Systems: I worked on the build infrastructure, ensuring that daily builds were stable and that the game could be successfully deployed to dev kits.

Rapid Growth

Starting as a Junior Programmer, I quickly proved my value through contributions to the tools and build systems, earning a promotion to Software Engineer. This period formed the foundation of my systems-level expertise, instilling the discipline required for high-performance C++ development.