Nikita Butenko

For about three months I ran a personal agent pipeline in the infrastructure repo. It took a ticket through implementation, review, a deploy into my own AWS test environment and QA. The QA agent had to show raw API output and Grafana screenshots. Every phase had a retry cap, and anything that got blocked came back to me. I've retired the pipeline under its own ticket once the agent tools caught up.

I keep the rule and skill tree in the infrastructure repo, linked into both Claude Code and Cursor, so every agent reads the same instructions. They cover the deployment model, Grafana alerts, ticket planning and release integration from four upstream services. One skill lets an agent push a pull request, watch CI and answer each review thread. In the trading monorepo the whole team shares the agent skills (incident investigation, financial verification, change verification). I've written most of them. All of the rules are in Simplified Technical English, and linters in CI check it.

The AI reviewer has rules so it doesn't repeat what the linters already said. Its failing tests run against the real code, and a finding without one is dropped before a person reads it. When an agent invents an API, I revert it under a commit that says so. The package gate also turns install scripts off.

Every difference between environments is an explicit if-statement in the CDK code, so there are no surprises. The part I like most is the deployment setup. Trading services deploy blue/green, both colours share one signer identity, each registers its own service discovery record, and a single DNS name flips between them in one atomic change. The infrastructure writes that DNS record once and never touches it again, so a deploy and a live cutover can't step on each other. Underneath there's a lock on a parameter store write, and it won't let the same holder back in if that would flip the release direction.

I've also replaced the observability vendor with a stack I put together myself: Grafana, Prometheus and Loki, with every dashboard and alert rule in git. Retention went from three days to thirty, plus a permanent archive, and we stopped sampling logs. The old setup dropped all info and debug logs from the index and kept one in a hundred of the noisiest errors, because that was the only way to afford it (I know, I had set that vendor stack up myself half a year earlier).

The protocol runs on several chains, so every upgrade first replays against a fork of each one, then the end-to-end suite runs through stake, borrow, trade, settle and liquidate. Contract addresses, ABIs and the protocol docs are all generated from the deployment, so nobody has to update them by hand.

At the same time I was shipping the apps themselves, mainly the liquidity app. I wrote the harder parts of the web3 client as well: a pull-oracle client that survives a failed gas estimate, and a revert decoder that turns a hex error into a sentence a user can read. A couple of CLIs and a CI step pin every build to a shared IPFS cluster and publish it. That became the standard way the protocol's apps ship. I wrote the IPFS part of the desktop node too, so anyone running a node helps serve the apps.

The monorepo came with its build system, packaging and CI.

The first (2021–2023) went from nothing to mainnet in about a year and a half, through several product versions. I was the main author of the client and the infrastructure. Users logged in with a wallet signature. Subscriptions were priced in dollars but settled on-chain as atomic transaction groups, and every media request was checked against live on-chain state.

After it wound down I started the second (2024–present), a media and NFT startup. I hired a developer to help, reviewed and merged their work, and built the platform, the content system and the AWS backend myself. The newest product there is almost entirely my own work, with a lot of agent automation.

As we kept adding sections to the portal, it became clear the classic UI build approach couldn't continue (build time was growing and development experience was deteriorating). So I came up with a new architecture: every product section became its own containerised React app, server-rendered in its own process, assembled into one single-page application at request time. A shared vendor bundle so no section ships its own React, namespaced globals and scoped CSS so sections can't collide, section state that survives navigating away and back. About ten separate frontends ran on it. At that time (end of 2016) there was no such thing as "micro-frontends architecture", so I had to invent one. The reference implementation of that pattern was published a few months after my prototype.

I also started ADAM, the Arbor Digital Attack Map, a WebGL globe and map of live DDoS activity. It began as a free-time research project, became a finalist of the company-wide innovation challenge, and shipped as the Map module of NETSCOUT Cyber Threat Horizon.

And I spent years on Agora, the deployment tool every engineer there used: Terraform generated from YAML for several hundred modules, containers on Mesos, monitors in Datadog, all in Ruby and shell. I didn't start it, but I was its top contributor for the last three years and ended up the one supporting it for everybody, just because I really enjoy working on tools and making everyone's life a little better.

Between Arbor and now (2020–2022). Three Sydney contracts. At icare, performance work and automated end-to-end testing on a large public site. At Woolworths' WooliesX, the API layer behind the mobile shopping app. At Ignition, platform work: a CI migration that made builds three times faster for about half the cost, monorepo packaging, and a UI testing strategy.

PeopleBrowsr (2013–2014). I built a new platform on NodeJS and my own modular frontend framework. Entity definitions were compiled from the server into the browser, so the same code ran on both sides (this was before isomorphic JS was a common thing). I interviewed and built the frontend team. We shipped several projects in about three months for the company's new top-level domains: the claim apps, the identity pages, and a domain storefront with Stripe payments and DNS through a registrar API.

The PHP years (2007–2013). At Cybertone I rewrote an internal CMS from scratch, built my own core on top of Zend, and reused it across more than thirty sites. At DAXX I was the developer and architect of a social networking startup, and ran the whole thing on my own SVN server. And there was e-commerce work at Ziller, Rocket Internet and others.

The start (2000–2007). In Ukraine I started with assembling and repairing computers, then was a sysadmin running over a hundred computers across six cities on one Windows domain. In 2004 I made my first commercial website, a PHP shop with a product catalog auto-updated from CSV (my version is still available in the internet archive). MSc in Computer Science, National Mining University of Ukraine.