It’s scandal time!

Your intrepid reporter has uncovered an outrage of major proportions: Not one of the major ERP suites … not SAP, not PeopleSoft, nor Oracle … scales effectively. It’s true!

Oh, they scale up just fine. I’m sure there’s some level of organizational size and scale where they break, but I don’t know what it is. Here’s what I do know, though: They don’t scale down very well.

Imagine you run a 45 employee company, and one of the above-mentioned vendors offered to give you their software for nothing. (Why? Maybe it’s a charitable non-profit whose cause they like. Don’t worry about it.) Both the cost of the license and the cost of annual maintenance and upgrades are covered. Not only that, but they’ll handle all of the installation, customization and integration.

Should you accept?

Probably not. I suppose it’s possible that with enough customization you could trick one of these packages into handling your operation, but what would be the point? Major ERP suites are built on a set of assumptions, largely hidden, regarding how a company operates. They assume, for example, you have an accounts payable department, with people who spend much of each day receiving invoices, matching them up with purchase orders, and routing them for approval to pay. They don’t assume you have Jill, who deals with maybe a dozen invoices a week in her spare time, getting approval to pay by yelling to the guy who lives three cubicles down, “Hey, Jack, did you ever get that toner cartridge I ordered for you?”

The scaling-down question has received little attention in IT, and it isn’t limited to software packages. Most of what we consider to be professional ways of implementing IT … the software, tools, and especially the methodologies … are designed for big. When your needs are small, they don’t scale.

Modern methodologies do recognize the fallacy of big projects. The idea of “chunking” big efforts into a collection of separate six-month projects executed by small, focused teams has entered the mainstream. You, however, have a four-person IT department which you lead when you aren’t busy helping the CFO figure out how to build a pivot table in Excel that links to an Access database. For you, an eight-person six-month project is far from small. It’s equivalent to the entire work output of your department for a year.

The heads of IT who run operations this size (they rarely call themselves CIOs) read about “industry best practices” and chuckle, knowing that using them would bankrupt their employer. “Best?” Not in a small company. When a large development effort is Ralph working with Jill to activate electronic bill pay in QuickBooks, it’s a sure bet Ralph shouldn’t first spend a month or two writing use cases. As for Ralph’s test plan: He’ll have Jill make a one-dollar payment to the company. If it arrives within a week, everything is working.

It’s been more than twenty years since IT discovered the importance of good process. And good process is vital in large companies. The reason it’s vital explains why scaling down is so hard. It’s the result of the formulas for two different kinds of line.

The first is the combinatorial formula: n(n-1)/2. It describes the number of relationships between employees, which translates to the cost of doing business through relationships. If you have few employees, you don’t need much in the way of process. Work gets done with little organizational friction because everyone knows everyone. With a lot of employees, though, everyone doesn’t know everyone, and the cost of doing business this way skyrockets.

When you rely on processes, in contrast, you apply a different formula: a*n + b. That’s the formula for a straight line, and what it means is that processes impose overhead, but scale well. It’s great when you have a lot of employees. The overhead becomes irrelevant compared to the ability to grow without costs going through the ceiling.

But if you run a small operation, be cautious about adopting them.

They weren’t, after all, designed to scale.

Long-time reader William Yohman points out a non-technical pitfall common to many end-user-developed IT applications:

“I developed dozens of applications, templates and procedures that were ‘the next best thing.’ I then trained the other users in my work center on their use (and how it would save them time) only to find out the momentum died when I left. These are intelligent, highly technical people who chose to go back to their previous frustration instead of continuing to use a product that was easy to use and saved them time. Why? Because no matter how good or how easy it was, it was easier to go back to the way they had done it a thousands times before. The reality is that ‘organizational memory’ only lasts until the alpha geek leaves the work center.”

Many end-user-developed applications fade away once their developer departs, no matter how good or useful they are. One reason is the difference between grassroots programming efforts and full-blown projects. The latter include training and business change management tasks that make sure the new system is institutionalized. They include establishment of a business sponsor who owns the change and is accountable for its success. And, when the new system comes in, the company “burns the boats” as it were — there is no way to go back to the old way of doing things.

Successful projects, that is, give end-users leadership, support, and an absence of alternatives.

With an end-user-developed application, all they get is support, and once the developer moves on, that’s gone too. There’s nobody to make additional modifications, answer questions, or help ensure that those using the application do so as intended instead of developing workarounds that pollute the data. Unless IT agrees to take on the job of support, use of the application grinds to a halt.

This isn’t necessarily a bad thing. Some of these applications are more conveniences than essential tools. They make life easier for awhile, but in the end the inconvenience of maintaining them outweighs their benefit.

Interestingly, the opposite can happen as well. As several readers have related, IT can develop a professionally engineered replacement for an “Access tangle” only to find that end-users refuse to abandon the application they’re familiar with, regardless of its limitations and inconveniences.

Sometimes, even well-accepted grassroots applications die; other times they stubbornly live on, even when IT provides superior replacements. What’s to do, other than shrug our shoulders and ponder the unpredictability of our fellow human beings?

Plenty.

First of all, whenever you’re responsible for implementing a new system, make sure to find out what home-grown applications are currently in use. Learn everything you can about them, and in particular, find out who their authors are.

Add those authors to your project team, either as full participants, or at least as subject-matter experts. Doing so will have two salutary effects. The first: By definition the authors are influential in the end-user community, so making them champions for the new system will increase acceptance. Second: By definition as well, the authors understand how to design a system end-users will embrace. Having them on the team (and paying attention to their ideas) will improve the design.

There’s one more benefit to including these folks on your project team. When the project is finished and the new system is in production, it’s just as important to turn off the home-grown applications it replaces as it is to decommission any large legacy applications the new system subsumes. The legacy systems, of course, are within the project team’s jurisdiction, so unplugging them is just another set of tasks on the project plan (“just” being a relative term, of course).

The home-grown ones are another story. If the project team shuts them down it might be considered an intrusion. If, on the other hand, the authors shut them down, it’s a powerful message to the end-users that the replacement system really is a better alternative.

Who better to burn the boats after all, than the shipwright who made them?