I build game systems that still run when the team that built them is gone.

15 years in mobile gamedev. Started writing shaders and squeezing FPS out of mid-range Android hardware. Ended up owning architecture decisions that determined whether a live game could scale — or had to be rewritten.

The pattern I kept seeing: teams move fast, ship something that works, then spend the next two years fighting the decisions made in week one. I got interested in the other path — systems designed with enough structural integrity that they survive growth, provider replacements, and headcount changes without requiring a rewrite.

That's still what I do. Hands-on. Designing and building, not just reviewing.

Interfaces before implementations. A system's public contract outlives its internals by years. I define boundaries first, build behind them second. When a vendor gets replaced or a requirement shifts, the blast radius stays contained.

Longevity is a design constraint, not a bonus. Short-term velocity that creates long-term drag is a cost that doesn't show up in the sprint. I factor it in from the start — not as conservatism, but as honest accounting.

Complexity has a budget. Every abstraction layer, every pattern, every indirection costs cognitive load. I spend that budget where it buys maintainability or replaceability. I don't spend it on elegance for its own sake.

Performance is architecture. On mobile, the constraints are real. I've built custom ECS from scratch under hard FPS targets, profiled draw calls at EA, and written terrain shaders to reduce overdraw. Performance decisions made late are expensive. Made early, they're just design.

A modular Unity framework distributed as UPM packages. Long-lived codebase design: stable contracts, zero cross-package coupling, replaceable implementations.

This is where I put the patterns I kept rebuilding at every company — distilled, documented, and designed to survive context switches between projects.

• drg.core — foundation contracts with no Unity dependencies: ISignalBus, IServiceLocator, ICommand, IMainThreadDispatcher. Everything else builds on top of these without depending on each other.

The design goal: a junior engineer joining a project built on drg.* should be able to replace any package implementation without touching the systems that depend on it.

License: DRG Fair Use License v1.1 — free for individuals and small teams (under $100k ARR), with a modest fee tier above that. Free for most users; sustainable for the ones where it creates real commercial value.

Open-source parental control app for Android TV. Kotlin, MVVM, Accessibility Service API. Built as a parent who wanted something transparent, free, and auditable. Because tools for digital wellbeing shouldn't require trusting a closed binary.

2010–2018 — Engineering depth. Sole developer on shipped titles. Contractor at EA. Custom ECS, rendering optimisation, shaders, multithreading, platform porting. Built the technical foundation that everything else runs on.

2018–2024 — Architecture and scale. Led teams of 3 to 12 engineers across multiple live titles. Designed LiveOps infrastructure, SDK abstraction layers, analytics systems, economy pipelines. Recovered 300k+ user saves post-acquisition. Cut backend costs 90% through custom infrastructure replacing Azure PlayFab.

2024–present — Platform and SDK focus. Building drg.* as a long-term open framework. Porting to Nintendo Switch (NDA). Exploring Cocos Creator and Telegram Mini Apps as platform alternatives. Looking for a Staff or Principal role where the work is still hands-on — designing and building systems, not just approving them.

Unity · C# · .NET · Kotlin · TypeScript · Node.js UPM · SDK design · LiveOps · DDD · ECS · data-oriented design Firebase · Nakama · Heroic Cloud · BigQuery · CI/CD iOS · Android · Nintendo Switch · Telegram Mini Apps

Staff / Principal Unity Engineer · Open to new opportunities · Lisbon, Portugal