I build things that give people back their time.

The old queue was built in the 2000s. It sat you in timers, broke whenever a third or fourth group was late, got worse with more than one group a side, sometimes left you stuck, and had no rematch, so every match paid the whole cost again. The lobby cuts queue-to-fight to about thirty seconds, takes several groups at once, has rematch built in, and lets a fresh player replace one who has dropped, which the old system could not do at all.

I rebuilt it because I play the mode and the queue was the worst part of it. That is most of how I choose what to fix.

Three constraints made it hard. Players already had a ceiling on what they could earn in an hour, and the feature could only sit a little above it. The game has many ways to travel, and a player carrying cargo had to be kept out of most of them. And every interaction crossed several servers, because the world only looks like one place, so each crossing needs a live answer to which server owns the vehicle, the cargo and the players on it. The arbitration already existed. The feature depends on the answer at every step.

The travel rule is the one I learned from. I blocked the paths I knew about one at a time. Players found the ones I had missed, finished a run in three minutes instead of twenty to forty, and support spent days clawing back money. The fix that held was to find the one place travel and vehicle storage pass through and put the check there. Guard the choke point, not the callers.

Polling was out first, because chat that arrives late is not chat. Discord's webhooks were out next: fast enough, but more complexity than volunteer hours could carry. A C++ Discord library gave instant delivery without the webhook work. Choosing C++ over something easier in JavaScript is what put the integration inside the chat engine instead of beside it. Other teams bridged theirs by logging a headless user into chat. Ours is one bot living in the engine as a singleton, with a permanent slot in the chat system.

Every command became a button. The connection became a configuration you enter once. And a sync function brings the client to whatever state the virtual machine is in, so switching branches cannot leave you testing on stale files. That mismatch costs an afternoon before anyone suspects the code was never the problem.

For the same team I built an in-game creator for non-player characters, so the people writing content stopped waiting on a developer, and web tools for player metrics, player management and automated patch notes.

Both exist for the reason everything else on this page does: the coordination was repeated work, and repeated work should disappear.

In the trade bot a crafter posts what they need, a miner takes the job, and the contract tracks itself to delivery, so the list keeps itself. In the event bot a match is a post with a button per side: players queue themselves, the post says when both sides are full, the schedule re-posts every week, and the results go out as an image when the match is over. The community's Discord adopted it as the event tool, which is what organizing over a thousand matches looks like.

Neither has a test suite. Both have years of uptime for real users on a box I administer myself, which is the other way to learn what breaks.

A React front end over a Node and Express API and MySQL. Cron jobs pull prices from a market data API through the day and fill open orders against them, so a limit order placed in the morning executes on its own when the price arrives. Prices are cached in the database and only re-fetched once they are an hour old, or a day old for end-of-day history, because every call to the data provider costs money. Version one ran on a Linux server behind NGINX, version two on AWS, and being on the hook for uptime changed what I look for as a tester.

The test plan runs on one rule: effort goes where the risk is, scored as impact and likelihood separately. The failures worth the most effort are the ones that do not announce themselves, like a malformed order that is still accepted and moves the wrong money an hour later. The suite is Playwright over the interface and the API, against the whole stack in Docker Compose. The unit tests run in GitHub Actions on every push and gate main. Three defects are written up with steps and evidence. The worst was a reset never wrapped in a transaction, which I had read and called harmless until I reproduced it.

Clients' stores and custom interfaces read the platform through the gateway. I tested it in Postman, request by request, and spent the rest of the QA year on manual and exploratory passes over the web application on its QA build.

Support wrote its escalations in the format from then on, so each one arrived carrying what engineering needed in order to take it.

A separate escalation was for a bug everyone had learned to work around. I added up its cost in support and engineering hours, about $50,000 a year, took the number to leadership, and the bug was fixed within a week.

C++ carries the systems and Blueprints sit above them as a thin configuration layer, so abilities, skills and stats are code with data on top rather than logic scattered through assets. The studio's rule is the same idea as everything above, pointed at play instead of work.