Case Studies

The Caribou Room had the bones of a solid infrastructure — building-wide ethernet wiring and a reliable CenturyLink fiber connection — but none of it was being used effectively. WiFi relied on two older, slow routers that couldn't cover the building adequately, the point-of-sale system ran on an aging router that had started glitching mid-service, and their Lutron Radio RA lighting hub was an early manufactured unit that shipped with insufficient RAM, leaving it permanently stuck and unable to take any later firmware updates. The venue had no way to prioritize bandwidth across different use cases.

• Designed and deployed a distributed WiFi network using existing ethernet runs, anchored by a high-powered core router to manage throughput across all access points
• Replaced the failing POS router with a reliable model, isolating that network for stability
• Identified a Lutron hardware limitation — early-manufactured hubs shipped with insufficient RAM and couldn't take later firmware updates — and worked with Lutron to secure a free upgrade to the latest Radio RA 3 platform
• Configured the new hub using Lutron's toolset, restoring app and device integrations and enabling the latest firmware
• Configured QoS rules and per-network bandwidth limits to protect the highest-priority systems

Nedernet is a small wireless ISP serving mountain communities in and around Nederland, Colorado using a network of nearly 500 Ubiquiti 5GHz WiFi links. As a licensed operator, they had the right to unlock the UNII reserved frequency bands on their devices — access to additional channels that significantly reduced interference in denser parts of the network. But the unlock process required rolling back each device's firmware to an older version exposing the unlock UI, performing the unlock, then re-flashing to the latest firmware: five to ten minutes per device across a fleet of hundreds, with no reliable way to verify unlock status beforehand. The team's visibility into device health was limited to old custom-built tools with only basic information, firmware updates were manual and disruptive, and the network's channel assignments had grown inconsistent — some out of compliance with FCC 5GHz specifications.

• Unlock Automation: Discovered the underlying unlock command line tool existed in every firmware version — not just older ones. Built a script that SSHes directly into a device and pushes the unlock key in seconds, with no firmware rollback required. Supported bulk operation across entire IP ranges and could audit devices to verify unlock status before any channel changes.
• AirControl Deployment: Installed and configured Ubiquiti's AirControl software, replacing limited custom-built tools with a real-time dashboard of every device on the network — service quality, signal levels, and device health — plus scheduled bulk firmware updates at 4 AM with minimal customer disruption.
• Channel Planning Tool: Built a custom React tool to visualize frequency band usage for any given area, showing which channels were in use, at what bandwidth, and how they overlapped — making interference-free planning concrete rather than guesswork.
• Network-Wide Replanning: Used the new unlock capability, network visibility, and visualization tool to re-plan channel assignments across the entire network, reducing interference in dense areas and fixing inconsistencies with FCC 5GHz channel specifications.

Generative art projects like ArtBlocks relied on a random seed at mint time to produce each token's unique artwork. The randomness source combined the block number, token ID, and minting address. Unlike a block hash — which is only known once a block is confirmed — the block number is fully predictable well in advance. This meant anyone could pre-compute exactly what output they would get from any given mint with no time pressure whatsoever: the inputs were public, the formula was public, and the result was entirely deterministic. No specialized hardware or speed advantage required — just the math.

To demonstrate the severity, I built two tools. The first, Omnipotent Artist, let anyone visualize exactly what token they would mint in any upcoming block. The second used Ethereum's CREATE2 opcode to deploy a contract to a precisely calculated address, then use that contract to execute the mint — making the minting address a controllable input, allowing iteration through potential addresses until finding one that produced exactly the desired token. To prove the real-world stakes, I demonstrated the exploit against ArtBlocks' Chromie Squiggles on testnet, generating pieces of greater rarity than some that had sold for millions of dollars. Rather than use Chainlink VRF — which would introduce an oracle dependency and async callback — I built a fully on-chain solution using data points that change unpredictably block-to-block as a byproduct of organic user activity: token supplies of assets like DAI and USDC that are constantly minted and burned in unrelated transactions. By reading several of these intractable, ever-shifting values into the randomness calculation, the seed becomes impossible to predict in advance.

TinyBoxes started as a generative art concept by Nate Alex — a Solidity script that randomly shuffled layered boxes to produce unique compositions. The original implementation stored the entire SVG output directly on-chain as a blob for each token. The result was prohibitively expensive: minting a single piece cost between $1,000 and $2,000 in gas fees just to store the SVG. At that price, the project simply couldn't ship.

Looking at the SVG output, I noticed massive redundancy — the structure was always the same patterns of elements with only certain values changing. It was a templating problem, or a special-case compression problem. I rebuilt the system around an on-chain renderer: a Solidity contract that takes a token's stored options and random seed and generates the complete SVG on demand using free read functions. Solidity has essentially no useful string handling primitives, so I built custom string parsing tooling from scratch and created a library of functions for each templated SVG chunk — constructing rectangles, applying animations, assembling layers. With storage costs solved, I expanded what the system could do: user-configurable parameters let minters set the bounds and feel of their piece while the algorithm made precise choices within those constraints, a UI let users explore the generative space before committing, and animations were added to bring the shapes to life — all cheap to include once storage overhead was gone.