Three Years, One Trading Bot, and the Case of the 28-Second Page

On October 29th, 2023, I paid OpenAI twenty dollars. On October 29th, 2026, that will be three years of building software by talking to machines. This is what I built, and what last week taught me.

I still have the invoice. Twenty dollars, October 29th, 2023. Then another twenty in November. December. January. The receipts stack up like ticket stubs from a concert you didn’t know would change your life.

I didn’t set out to spend three years on this. I set out to answer a question that had been bothering me for a while.

The thesis

Everyone talks about Bitcoin going up. Buy it, hold it, wait, retire.

I think that’s the small opportunity.

The bigger one is the volatility itself. Crypto, stocks, currencies, ETFs — these things move constantly, in patterns, all day and all night. The appreciation is a story about one number getting bigger. The volatility is a story about thousands of numbers moving against each other, every hour, forever. That’s a much larger surface to work on.

Plenty of software exists to trade that volatility for you. I looked at it. And I ran into a personal obstacle I couldn’t reason my way past:

I don’t want to trust somebody else’s software with my money.

Not because I think they’re crooks. Because I’ve spent thirty years in systems administration watching software do things nobody intended, on machines nobody was watching, for reasons nobody documented. I know what’s in there. I know that “it works” and “I understand why it works” are different statements, and only one of them lets you sleep.

I recognized Bitcoin’s value back when you could buy ten of them for a penny — not because I’m clever about markets, but because I already had a healthy distaste for how the banking system operates, and Bitcoin was legible to me in a way it wasn’t to most people at the time.

So I had the ingredients: thirty years of systems administration, just enough software development to be dangerous, an early conviction about crypto, and a stubborn refusal to outsource trust.

What I didn’t have was the ability to write an institutional-grade trading platform by myself.

That’s what the twenty dollars was for.

What three years buys

Nearly three years later, the thing exists. It’s called Secant Trading Systems, and it does what I dreamed it would do:

It watches markets across multiple exchanges. It reads the news and quantifies sentiment — not “this article seems positive,” but thirty separate numerical indicators across six categories. It identifies candlestick patterns. It designs strategies, backtests them against real history, and lets me set my own risk tolerance rather than accepting someone else’s defaults.

And before it places a trade, it asks an AI to check its own work — a second opinion, running as a safety gate, with the authority to veto.

This week, it starts paper trading. Imaginary money, real markets, real decisions — to prove it can track what’s actually happening before a single real dollar is at risk.

I self-funded all of it.

Which brings me to last week, and a lesson about what software will do when you’re not looking.

The Case of the 28-Second Page Load

It started with a complaint that sounds like nothing: the pages were slow.

Not broken. Not erroring. Just slow. Click a chart, wait. Type three letters into a search box, wait some more. Twenty-eight seconds for a price chart. Thirty-eight to search for “bnb.”

If you’ve ever watched a spinner and wondered whether it’s your internet, your laptop, or the universe expressing an opinion about your life choices — you already understand the emotional core of this story.

Here’s what made it interesting. Every measurement said the system was fast.

The market data: 0.14 seconds. The exchange it came from: 0.18 seconds. The cache: warm, three hours of life left. The machine itself: 32 processor cores, 39 gigabytes of free memory, disk essentially asleep. Another engineer had investigated the day before and hit the same wall — every page served in about two-tenths of a second.

So: a fast server, a fast network, a fast database, and a website that took half a minute to draw a chart.

Somebody was lying.

Six tables, four of them permanently occupied

The answer was a rule most people have never heard of, written into the plumbing of the web in the 1990s and still quietly shaping your afternoon.

When your browser talks to a website, it opens connections — little pipes for requests to travel through. Under the old protocol, a browser opens at most six pipes to any one website. Sensible when web pages were documents. Much less sensible now.

Modern apps hold some of those pipes open permanently. A live price ticker. A notification feed. A voice assistant waiting to be spoken to. Each grabs a pipe and never lets go, because that’s the entire point — a permanent open line for updates to stream down.

This app had twenty-three such connections scattered through it. One of them — the voice assistant — loaded on every single page.

Six tables in the restaurant. Four occupied by people who ordered a coffee in 2019 and never left. Everyone else queues at the door.

When I measured the actual connections, they sat at exactly six. Not five. Not fluctuating. Six, pinned, for twenty seconds straight. Saturated.

The requests were never slow. They were never sent. They were standing in the browser’s lobby waiting for a table, while every stopwatch I pointed at the kitchen reported that the kitchen was doing great.

The fix was one line of configuration — switching on the newer protocol, where a browser opens one connection and runs a hundred requests through it at once. Six tables became a hundred.

I reloaded and tried again. The page snapped in instantly.

Bitcoin was trading at eighty dollars

The slow page wasn’t the first liar we caught last week. Just the best at it.

A few days earlier I was looking at a Bitcoin price chart and something was off. It took a second to spot: the chart said Bitcoin was worth about eighty dollars.

Bitcoin was worth about sixty-four thousand dollars.

There were also little markers labelled “MSTR” and “EVST” — stock ticker symbols, which have roughly as much business on a Bitcoin chart as a submarine has in a bakery.

The system had tried to fetch real prices, failed, and then — rather than saying “I couldn’t get the data” — quietly invented some. Plausible candlesticks. Convincing wiggles. Entirely fictional. There was a small warning banner, to be fair. But the chart underneath looked completely real, and on a platform that makes decisions about money, a chart that looks real and isn’t is the worst failure available.

We found that same instinct — fail silently, substitute something plausible — five separate times in five disguises: pick one exchange and get another’s prices; a cache that forgot which exchange data came from; every XRP pair force-redirected elsewhere based on a code comment stating a confident falsehood; a connector handed data in a format it couldn’t read, swallowing the error; and the demo generator above, cheerfully painting fiction.

None malicious. Every one was a developer writing the reasonable-seeming line: if this fails, fall back to something. Good instinct in most software. In financial software it’s a loaded gun, because the fallback is indistinguishable from the truth.

The fix that fixed nothing

My favourite moment was one where I was the one being lied to, by my own work.

I found a security problem: an internal service accepting connections from the whole network with no password. It was only supposed to be reachable from the machine itself.

I found the line of code, changed it, restarted, checked.

Still open.

Checked again. Same. The code definitely said the safe value. The service had definitely restarted. The port was definitely still exposed.

The explanation was almost elegant: the service wasn’t started by that code at all. It was launched by a startup script that set the same option itself, using a slightly different name for the same setting. My fix was real, correct, and applied to a code path nothing had run in months.

A fix that restarts cleanly and changes nothing is worse than no fix, because now everyone thinks it’s solved.

New rule: verify the observable, not the edit. Don’t check that you changed the code. Check that the world changed.

Ghosts

Two background services had been crash-looping for months — starting, failing, restarting, forever. Combined: about 22,800 restart cycles. Neither could ever start, because both were trying to load an application that had been deleted from the project. They were haunting a house that had been demolished.

And a database table turned out to be completely unreadable by the application. Investigating, I found that no database migration in the entire project had ever granted permissions. Not one, ever. Nobody had noticed because years ago someone hit the error on a single table and fixed that table by hand — which cured the symptom, hid the pattern, and left every future migration free to reintroduce it.

The part where it becomes precious

Somewhere in the middle of all this, I went and bought a fire safe.

Let me explain how that happened, because it’s the part of the story I find most human.

For a long time, the backup was a USB memory stick. That’s fine when your project is source code. Source code is small. A few hundred megabytes of text that took three years to get right, but still — text.

Then the project grew a brain.

Part of what makes this system work is language models running locally on my own hardware — models I’ve fine-tuned on trading knowledge, so the AI safety-check doesn’t depend on someone else’s servers being up, or someone else’s terms of service staying the same. That’s the same instinct as the rest of the project: don’t outsource the thing you’re depending on.

But fine-tuned models are not text files. They’re hundreds of gigabytes. Thirteen model directories, and growing.

The memory stick wasn’t outgrown gradually. It was outgrown suddenly and completely, like a kid going up two shoe sizes over a summer.

So: an external hard drive. Two terabytes, formatted properly, with room to breathe. Last week we rebuilt the backup system to use it — and found the old script had been quietly missing several of the fine-tuned models, because it worked from a hardcoded list somebody wrote once and never updated. (Another liar. They’re everywhere once you start looking.) Now it discovers them automatically.

The current backup: 124 gigabytes. Sixteen databases. Thirteen model directories. The complete git history. Every configuration file. The whole machine, essentially, reduced to one drive.

And then I stood there holding it.

Three years. A thousand-odd dollars of AI inference, twenty at a time. Every design decision, every argument with myself at 2am, every bug like the ones above — all of it, in one object I could drop.

So I bought a fire safe, and I put it inside.

There’s something clarifying about that moment. Software feels abstract right up until the point where it doesn’t — where it becomes a physical thing on a shelf, worth protecting from fire, because it represents years you cannot get back.

Now I spend $200 a month on Claude Code – one of Anthropic’s biggest AI inference subscriptions. The kind of work that I am doing through self learning, experimentation is what people in silicon valley are getting paid 40 million dollars a year to do according to Marc Andreesen. It feels like I’m commanding 40 full time programmers to build the enterprise software of my dreams. Will it work? Will this endeavor pay off? I think so and I’m not sure.

One thing is for certian – I’m gaining incredibly valuable experience.

The thread

Last week had a theme, and it wasn’t “computers are hard.”

Almost none of these were things that broke. They were things that reported success while failing, or failure while fine. The chart displaying fiction. The cache serving the wrong shop’s goods. The service that restarted without changing. The backup script confidently skipping files. The ghosts, restarting forever into nothing.

The pages were the same story. Every instrument said fast. The human said twenty-eight seconds. Both were telling the truth — the instruments were pointed at the kitchen, and the problem was the queue at the door.

If there’s a lesson, it’s smaller and more boring than “use better tools”:

When a system tells you it’s fine and a human tells you it isn’t, the human is describing something real that your instruments aren’t pointed at yet.

Find out what you’re not measuring.

That, more than anything, is why I built this myself. Not because I can write better code than a trading firm — I can’t. But when this thing tells me it’s fine, I know exactly which instruments it’s using, where they point, and what they can’t see.

Three years. One trading bot. Paper trading starts this week.

Secant Trading Systems founded by Joseph William Baker®. He has thirty years in systems administration, an unreasonable number of opinions about the banking system, and a fire safe with a hard drive in it.