The System That Wouldn’t Die

On a dark and stormy night in 2011, a younger, far more naïve developer (me) took on a task that should have raised more red flags than it did.

We needed to replace a DOS-based transaction tracking application. It had been around forever. Nobody liked it. Nobody fully understood it. But it worked, and that made it dangerous. Oh and I forot to mention it was written in Haskell and i didn’t even have access to the source code because the one machine left running it was completely dead. I tried like an eager emt on a wild friday night to revive the hard drive in the hopes of being able to salvage something but it was gone…all gone. Luckily back in the olden days they printed out all of the transaction data so there was a “backup”

The requirements were simple.
Or at least they sounded simple.

• Low cost
• No hosting
• Built fast
• Temporary

I had a week.

The Language Best Left Unspoken

With limited time and fewer options, I reached for the scariest tool I knew at the time: VBA.

Specifically, Microsoft Access.

We already had licenses. It ran locally. No servers. No infrastructure. No ongoing costs. It felt pragmatic, almost responsible.

I told myself it was temporary.

I spent nights hunched over forms and modules, ripping my way through recordsets, duct-taping logic together, convincing myself that if it just worked long enough, it wouldn’t matter how it was built.

And somehow… it worked.

The Years Passed

As the days grew shorter and the nights grew longer, the weeks turned into months.
The months turned into years.

“The Software,” as it came to be known, just kept chugging along.

It survived OS upgrades.
It survived staff turnover.
It survived my growing understanding that temporary systems have a habit of becoming permanent.

Eventually, I moved on. New roles. New stacks. New languages. Python replaced VBA. Databases lived on real servers. Deployments became repeatable. Observable. Clean.

I buried Access alongside other things I’d rather not think about.

Or so I thought.

It Came Back

One dark and dreary day in 2025, the past clawed its way back into the present.

The request was simple:

“We need a new version of The Software.”

By then, my primary development machine was a MacBook.
My daily tools were Python, Django, modern databases, real deployments.

VBA was supposed to stay locked away with my most repressed memories.

But there it was.

Still running.
Still critical.
Still very much alive.

The Horror of Legacy

The real terror wasn’t that the system existed.

It was that:

• People depended on it
• Data lived inside it
• Nobody wanted it to break
• And everyone assumed it would “just keep working”, not me I just prayed

Legacy systems don’t haunt you because they’re old.
They haunt you because they worked just well enough to never be replaced.

The Lesson

This isn’t a story about Microsoft Access.
Or VBA.
Or bad decisions made under pressure.

It’s a story about what happens when “temporary” isn’t given an expiration date.

Every developer has a system like this somewhere in their past.
Something built late at night.
Under constraint.
Meant to disappear quietly.

Sometimes it doesn’t.

Sometimes it waits.

---

It was past midnight when I reopened that file.
The same file I swore I’d never touch again.

— The Caretaker