Nikita Butenko

AI Automation & Platform Engineer · a futures trading platform (contract)

AWS, CDK, CircleCI, NodeJS, TypeScript, Go, ReactJS, EVM smart contracts, Foundry, Cannon, Grafana, Prometheus, Loki, MCP, Claude Code, Cursor

AI tooling, infrastructure and ops (2025–present). Since mid-2025 agents write most of the code I ship here: CDK for the AWS platform behind the exchange, Go services, deploy tooling. For about 3 months I ran a personal agent pipeline. It took a ticket, implemented it, reviewed it, deployed it into my own AWS test environment and ran QA on it. Every phase had a retry cap, and anything that got blocked came back to me. I've retired the pipeline once the agent tools caught up, and the same steps now run as skills under Claude Code and the Cursor CLI, mostly in full auto mode.

For security reasons agents only get access to test environments, dev and production deploy through CI only. 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. One skill lets the agent push a pull request, watch CI and answer each review thread. I've written most of the shared agent skills in the trading monorepo too. All rules are in Simplified Technical English, with linters in CI.

Sandbox and AI review tooling. Every agent runs in a container that sees one project folder. I've shared the setup with the team and some of them use it too. A hosted AI reviewer runs on every pull request, with rules so it doesn't repeat the linters, and a validator makes it prove each bug it reports with a failing test, run against the real code. When an agent invents an API, I revert it under a commit that says so. mcp-review is a code review tool for agents: the agent sends its changes, a person reviews them in a web page, and the agent picks up the comments. A comment goes stale when the code under it changes. I've built it on my own, a working version in a couple of days, and then kept refining it.

The agent work is the latest phase of this contract, my main job since 2022. In that time the product went from a DeFi protocol, to on-chain perpetual futures, to a high-frequency trading platform. The current one runs mostly off-chain with on-chain components. My role moved with it: frontend, then the release process, then the AWS platform under the trading engine.

The platform. I've built the AWS platform behind the perpetual-futures exchange from scratch and stayed its main author for over a year. It's dozens of CloudFormation stacks per environment across 5 AWS accounts, all generated from one CDK entry point. Trading services deploy blue/green behind a deploy lock, so a routine deploy can't race a live cutover. Maintenance windows went from 30–40 minutes to under 2, and the platform passed an independent security audit. I've also replaced the observability vendor with self-hosted Grafana, Prometheus and Loki: the bill dropped by more than 80%, retention went from 3 days to 30, and we stopped sampling logs. I wrote Go for the backend services as well and designed their e2e test suite.

Deployment, testing, automation and a family of dApps (2022–2025). I was responsible for the release process of a multi-chain protocol. Every upgrade first replays the pending deployment against a fork of each live chain, then runs an end-to-end suite that stakes, borrows, trades, settles and liquidates. A generator rebuilds deployed addresses and ABIs and publishes the protocol docs, so nothing downstream is maintained by hand. At the same time I shipped a family of dApps, mainly the liquidity app, started the protocol's public React SDK and the hooks library under it, and wrote the harder web3 client parts: a pull-oracle client, and a revert decoder that turns a hex error into something a user can read. I also built the tooling that moved the frontends onto IPFS and ENS: CLIs and a CI step that pin each build to a shared IPFS cluster and publish it. It became the standard way the protocol's apps shipped.

Frontend (2022). I came in as a frontend engineer and worked on the staking dApp and on the shared component monorepo that all frontends were built on: build system, packaging, CI.

Co-founder · two Web3 product startups

TypeScript, NodeJS, ReactJS, AWS CDK, EVM smart contracts, Foundry, The Graph, agent tooling

Two startups as tech co-founder, one after the other, alongside the contract work above. Responsible for the full spectrum of technical tasks: product, frontend, infrastructure and smart contracts.

The first (2021–2023) went through several product versions and reached mainnet in about a year and a half. 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, reviewed and merged their work, and built the platform, the content system and the AWS backend myself. The latest product there is almost entirely my own work, with a lot of agent automation.

Senior Software Engineer · Arbor Networks / NETSCOUT (ATLAS)

ReactJS, NodeJS, Ruby, Shell, AWS, Terraform, Docker, Datadog, Mesos/Singularity, WebGL, ThreeJS, D3, Lerna, Monorepo, Micro-Frontends

Architected and developed a global network visibility platform as part of the new ATLAS team.

As we kept adding sections to the portal, the classic UI build approach stopped working (build time was growing and development experience was deteriorating), so I came up with a new architecture. Every product section runs as its own containerised React app, server-rendered in its own process, all assembled into one single-page application at request time. Sections shared one vendor bundle instead of each shipping its own React, kept their globals and CSS namespaced so they couldn't collide, and kept their state across navigation. 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 started ADAM, the Arbor Digital Attack Map, a WebGL globe and world map of live DDoS activity. It began as a free-time research project, became a finalist of the company-wide NETSCOUT Innovation Challenge, and shipped as the Map module of NETSCOUT Cyber Threat Horizon.

I spent years on Agora, the internal deployment tool every engineer used to ship: Terraform generated from YAML for several hundred modules, containers on Mesos, monitors in Datadog, in Ruby and shell. I didn't start it, but was its top contributor from 2018 until I left, and by the end the one supporting it for everyone.