The Half-Fast DevOops Manifesto on Technical Debt

TL;DR   Technical debt is a receipt, not the monster under the bed. The monster is everything you didn’t manage, track, or admit. Or, more likely, the people before you didn’t manage, track, or administer.

There’s a moment in every failing software project when someone, usually wearing a lanyard heavy with conference swag, sighs and tries to look profound, which looks more like constipation, and declares:

“Well, this wouldn’t have happened if we didn’t have so much technical debt.”

As if the old codebase woke up one morning, donned a ski mask, and robbed the production environment.

It didn’t.

Technical debt doesn’t do anything on its own. Debt never has agency. Debt doesn’t get up from the basement server room, stretch its ancient joints, and sabotage your latest sprint.

It just sits there.
Quiet.
Honest.

A record of choices you made in the fog of delivery.

Debt isn’t the villain.  

Debt is the witness.

What actually hurts you, breaks systems, burns out engineers, and causes 2 A.M. patch parties with people of questionable sobriety, is the same force that doomed countless “digital transformations” before yours:

mismanagement, denial, delusion, and the relentless fetishization of velocity.

But let’s start at the beginning.

I. The Cult of Blameless Technical Debt#

Most organizations use technical debt as their default scapegoat. A digital goat you can chase into the desert every time a release misfires.

That thinking gets reinforced by Very Serious Industry Articles™ like the recent IEEE Spectrum piece, which points out that we’ve spent trillions on IT and software yet still manage to trip over the same cracks in the sidewalk.¹

We replatform.  

We modernize.  

We migrate to the cloud.  

We adopt Agile, DevOps, DevSecOps, DevSecBizAIOps, and whatever new TLA the industry coughs up this quarter.

And still, projects crater in familiar ways.

Each time, the conclusion is the same:

“Technical debt did this.”

But no.

Debt didn’t. Your process did.

Debt is neutral.
Process is not.

Debt is a trade-off.
Process is your belief system.

Debt is a byproduct.
Process is a choice.

And many organizations choose chaos and call it velocity.

II. Technical Debt Is Not Decay; It’s a Ledger#

Let’s draw a line in the sand:

Technical debt ≠ technical rot.

Rot is neglect.
Rot is abandonment.
Rot is the legacy/ folder nobody has opened since Obama’s first term.

Debt, meanwhile, is simply:

“We chose to do this faster, and we understand the consequences.”

Debt says:
“We made a trade.”

Rot says:
“We made a mistake.”

Debt is honest.
Rot is denial.

Debt can be paid down.
Rot is a haunted house.

Debt is the motorcycle you ride while the car is still in the shop.
Rot is the flaming Pinto behind your office.

Technical debt, done right, is intentional. It’s the gap between the ideal design and the version you ship, so customers can use something before the sun expands and consumes the Earth.²

Rot happens when you leave that gap unacknowledged, unmanaged, and unowned for… several fiscal years, often out of spite.

III. Why Most “Tech Debt Is Dangerous” Arguments Are Just Complaints About Bad Leadership#

Here’s the cosmic joke:
Nearly every warning about the dangers of technical debt boils down to:

“If you don’t manage things well, bad things happen.”

Which is both true and wildly unhelpful.

• If you don’t manage microservices well, they go nuclear.  
• If you don’t manage Kubernetes well, it becomes a petty god you must appease with YAML sacrifices.  
• If you don’t manage monoliths well, they calcify into Lovecraftian ruins.  
• If you don’t manage Agile well, it becomes a cosplay religion with stand-ups as communion.

Everything needs management.
Everything nosedives without intention.

So, blaming technical debt for broad-spectrum organizational incompetence is like blaming your car loan for forgetting to change the oil.
Debt isn’t the problem.

Neglect is the problem.
Debt isn’t toxic.  

Delusion is toxic.
Debt isn’t fatal.  

Process failure is fatal.
Debt is not the murderer. It’s the chalk outline.

IV. The Good Debt: Yes, Sometimes It’s the Winning Move#

Let’s pause our cynicism and talk facts. Some of the most successful tech titans didn’t evade technical debt. Instead, they weaponized it.

Facebook: Duct Tape to Domination#

Early Facebook ran on a PHP monolith held together by duct tape, spit, and good intentions. It wasn’t pretty. It wasn’t pure. It definitely wasn’t what a modern architecture any reasonable, sane review board would approve.

But it shipped. Fast.

Only after winning did they invest in HHVM and Hack, rebuilding the engine while the plane was already at cruising altitude.³

They took on debt consciously in exchange for speed and market dominance.

Netflix: Chaos as Strategy#

Netflix didn’t wait for the perfect cloud platform. They moved to AWS before AWS had the features we now take for granted. They embraced:

• incomplete tooling  
• inconsistent patterns  
• limited observability  

…in exchange for resilience, scale, and global reach.

Only later did they clean it up with world-class SRE practices and a discipline in chaos engineering.⁴

They took on debt consciously in exchange for future capability.

Etsy: Fifty Deploys a Day and a Prayer#

Etsy’s famous “Code as Craft” culture didn’t start from perfection. It started from:

• frequent deploys  
• messy monoliths  
• rapidly evolving tooling  

They tolerated imperfections to maximize feedback loops and learning, then gradually hardened the system as practices matured.⁵

They took on debt consciously in exchange for learning and cultural transformation.

Stripe and Slack: Monoliths, Shortcuts, and Timing#

Stripe leaned on a large monolith and moved fast to become the payments API developers loved.⁶

Slack grew from patched-together IRC-flavored foundations into a multi-billion-dollar platform.⁷

They all had the same play:

Borrow from tomorrow so you can exist today.

These companies didn’t succeed despite debt.
They succeeded because they treated debt as a strategic, intentional trade-off, not as rot.
They accrued debt like athletes accrue soreness. Part of the training, part of the growth, part of the game. Part of it is just a part of life.

V. The Bad Debt: Where Most Companies Actually Live#

Now for the part that stings.
Most organizations don’t have strategic debt.

They have the other kind.
The kind born of shortcuts, fear, silence, and meetings that could’ve been emails.

Bad debt is:

• undocumented  
• unexamined  
• unowned  
• unplanned  
• unmanaged  
• unloved  
• occasionally cursed by ancient developers who left in 2017

This isn’t technical debt.
This is technical amnesia.

It’s not the loan that hurts you.
It’s your refusal to budget the payment schedule.

It’s the “we’ll fix it later” that never becomes “now.”

It’s the TODO comments that could be carved into gravestones.  

It’s the Jira tickets that got triaged and sent to the bottom, ignored.

Debt is fine.
Untracked debt is not.

Debt is normal.
Denied debt is not.

Debt is neutral.
Debt plus cowardice is not.

VI. Velocity Without Purpose Is Just Fancy Self-Harm#

Ah, velocity.
The corporate FitBit metric for “How Fast We’re Pretending to Move.”

Velocity isn’t inherently harmful.
Velocity isn’t inherently good.
Velocity is just a number.

But velocity without context destroys teams.
Velocity without purpose creates shortcuts.
Velocity without honesty creates debt.
Velocity without backlog tickets labeled “FIX THIS OTHER THING WE BROKE” creates hallucinated progress.

You want to go fast? Great.

But going fast at nothing is panic with better branding.
Going fast without intention is stress cardio.

Going fast while ignoring debt is an express shuttle to:

“Why is prod on fire, and why does nobody remember how this works?”

Velocity is only valid when tied to:

• clear outcomes  
• honest trade-offs  
• explicit ownership  
• actual business value  

Everything else is just numbers cosplay for the executive deck.

Velocity is not a virtue.

Purpose is a virtue.
Clarity is a virtue.
Owning your messes is a virtue.

Velocity should just be a tool, hopefully not used by fools.

And like any tool, it can build or destroy, depending entirely on whether anyone bothered to think before swinging it.

VII. So What Do We Actually Do About Technical Debt?#

The answer is not “eliminate all debt.” That’s fantasy-land. The answer is to treat debt like adults treat credit and risk.

1. Track your debt.#

Write it down. Make it visible. If it’s not written down, it’s not strategic. It’s just the future screaming in advance.

2. Own your debt.#

Every meaningful shortcut needs an owner. Not a committee.   An actual human name.

3. Schedule your debt.#

If it isn’t on the roadmap, it’s one of those stories: a legend, a myth, or a tall tale. Block time. Block sprints. Call them what you want:

• “Refactor Fridays”  
• “Interest Payments”  
• “The Great De-Entropy”  

Just put it on the damn calendar.

4. Tie speed to outcomes, not to vanity metrics.#

If velocity goes up and user happiness doesn’t, it’s not progress. It’s motion.

5. Stop confusing age with danger.#

Old systems aren’t automatically bad.
COBOL is not a crime. Legacy mainframes are not inherently villains.

They’re more like grumpy old neighbors: occasionally inconvenient, but the reason the street still exists.

Neglect is the crime.
Silence is the crime.

Replacing something that works with something no one knows is a crime. It is also stupid, which should be a crime, but doing so would be a logistical nightmare.

6. Stop blaming technical debt for organizational dysfunction.#

Debt didn’t make your release fail.
Your process did.

Debt didn’t burn out your engineers.
Forcing them to sprint across a minefield of known issues while pretending everything is fine, tthat did.

Debt didn’t kill your transformation.
Confusing a slide deck for a strategy did.

VIII. The Half-Fast DevOops Grand Finale#

Here’s the truth, told slowly in Rod Serling’s voice under a single spotlight:

“Technical debt never hurt a soul.
Mismanagement did.
Denial did.
Worship of velocity did.
The refusal to own trade-offs did.”

Debt is simply the ledger of choices

the record of the roads you took,
the shortcuts you embraced,
the realities you accepted,
and the time you borrowed.

Debt is not shame.
Debt is not sin.
Debt is not moral failure.

Debt is the universe reminding you:

You can do anything
you just can’t do everything.
Not all at once.
And not for free.

The rock of Sisyphus rolls either way.

Better to choose the hill.  

Better to understand the incline.  

Better to own the push.

Technical debt didn’t hurt you.
Your process did.

And the sooner we stop blaming the witness for the crime,  the sooner we can get back to building systems worth their weight in uptime.

Footnotes#