The Company That Changes Development Vendors Every Year, and Every Time Hears "The Last Vendor's Code Is Garbage"

The other day, an engineer friend told me an interesting story.

At a system my friend is involved with, the client apparently replaces its development vendor about once a year. This is not about new development. It’s about a company that hands over an already-running web service or business system to a vendor for ongoing feature additions and bug fixes. As long as the business continues, this kind of system never stops needing more development.

And yet, this company keeps switching vendors: from Company A to Company B, from Company B to Company C. And every time a new vendor comes in, the engineers apparently say the same thing.

“What is this garbage code…”

Was the previous vendor incompetent every single time? Can that kind of coincidence really keep happening?

Development Vendors Don’t Expect to Profit From the First Contract

A development vendor wants to win work from a new client. There’s competition, so sometimes the first quote is on the low side.

In exchange, the vendor expects ongoing development to continue. As features are added, there’s room to negotiate a bigger contract. Even if the contract doesn’t grow, the longer they handle the same system, the less internal effort it takes.

At first, just reading the code takes time. You don’t know the database structure or the history behind it. But after handling it for a year, you start to know, “This feature is probably around here,” and an investigation that used to take three days takes half a day.

In other words, a vendor accepts thin margins at first, planning to make it back over the long term.

But some client companies switch vendors before that payback even begins.

Use Them Only During the Cheapest Period, Then Move On

The company in my friend’s story changed vendors every year, or every two years at most.

The current vendor starts bringing up a change in contract terms. The executives talk to a new vendor too. A low quote comes in. “This one’s cheaper. Let’s switch.” And then it repeats.

From the client company’s point of view, “the new vendor is cheaper.”

Of course it is. It’s always the first contract.

Pretty clever. At least, that’s probably what they think.

Stacking Garbage Code on Top of Garbage Code

The new vendor receives the source code. But they don’t have the knowledge the previous vendor had.

Why was it designed this way? What failures happened in the past? Why does only this table have such a strange structure? Why must nobody touch this process? There may have been a reason at the time, but no one who knows it is left.

And the engineers say: “What is this garbage code…”

Well, I understand the feeling. I’ve said it more than a few times myself.

And the new vendor has no time. Just because they’ve taken over the system doesn’t mean the client will let them spend six months reading code. That almost never happens. “Please add this feature.” “We need it by next month.” Ordinary feature development starts right away.

They’d like to clean up the design. But there’s no budget. They’d like to refactor. But there are deadlines. In the end, they implement things to match the existing code.

Then, a year later, yet another company comes in and reads the code.

“What is this garbage code…”

The previous vendor said the same thing about the vendor before them. A lovely relay race, passing the baton.

”The Last Vendor Was Bad” Every Time Is a Little Suspicious

The story “the previous vendor’s quality was bad” is not unusual in the IT industry. And some vendors really are terrible.

Once, I can understand. Twice, maybe. But three vendors in three years, and every time the previous one was to blame? That’s a little suspicious.

It’s like relationships. Some people say, “Every partner I’ve ever had was a jerk.” Maybe the first one really was. Maybe the second was bad luck. But if all ten were jerks, you can safely say the problem is you.

To the Next Vendor: My Condolences

If your sales team tells you, “The client says the previous vendor’s quality was bad, so they’re switching to us,” you should check one thing.

Which company built it before that?

Three vendors in the past three years. And all of them “had bad quality.”

I see. My condolences.

A year from now, you’ll probably be “the previous vendor with poor technical skills.” And the next vendor’s engineers will look at the code you wrote and say:

“What is this garbage code…”

Don’t worry. You said the same thing a year ago.

This relay will continue until the system truly becomes unmanageable and the company spends a fortune on a complete rebuild. On that day, the client will probably say:

“Please investigate why our system ended up like this.”

Why?

Just line up the list of past vendors in chronological order.