The economics of the software development business

The economics of the software development business have always been kind of weird. Some things with software scale spectacularly, and some things scale very poorly. Pricing is always a challenge; it’s hard to know when it is right. Even what, exactly, is being sold has always puzzled the best thinkers in the software business. And of course, open-source software throws a monkey wrench into the whole works.

For the first few decades, all software was bespoke. IBM and others sold mainframes and mini-computers, and software was normally sold with the computer and customized for each customer. Eventually, larger firms had in-house developers who wrote software for their company’s particular needs. There wasn’t a broad market for software, so software was expensive and limited to larger companies that could afford the esoteric hardware needed to run it. Economies of scale were extremely limited. 

The notion of “software as a product” came about as a result of a US Justice Department case that forced IBM to unbundle the software from its hardware. Eventually, the advent of the personal computer allowed for a broader software market.

I remember well going into a Computerland store and browsing for computers and boxes of software stored on floppy disks. Shoot, you could buy a computer and software at Sears. 

Peddling disks

The economics of the software package era were interesting. Each version of a given software package was to be written, tested, documented, burned onto disks (floppies, CD-ROMs, DVDs), and delivered to a store before even a dollar of revenue was realized. 

Customers expected extensive documentation, making for a heavy, hard-to-transport product. (The famous Borland C++ 3.0 box was around a foot and a half long and weighed upwards of 25 pounds.) And in the early days, the documentation wasn’t enough—customers expected and got free telephone support. You read that right: free, live telephone support. It didn’t last long. It eventually moved to pay-by-the-minute support, before all support went online.

The PC revolution also brought on the advent of shareware—a “try before you buy” model that has gone by the wayside, but was widely used by small developers at the time. Executable installers were downloaded from CompuServe, AOL, and bulletin board systems (and of course later from the Internet), and passed around via floppy disks at user group meetings.

The software would either be limited in functionality, display “nagware,” or run for only a limited period of time. Users could mail a check to the author, who would then send a license key that would unlock all of the features of the software. (I was a humble shareware vendor back in the 1990s, but I am vexed that the Internet seems to have no memory at all of any of my programs.)

Despite how the software was sold or delivered, just like today it all had bugs, and the vendors needed to deliver updates and patches, usually via a physical medium. Because the installs were static, those fixes were few and far between, and had to be batched up and delivered physically like the original package. Users learned to live with bugs.

New features were delivered the same way, with a “major point release” that users had to pay for. Convincing users that the latest version was worth the upgrade became a challenge, particularly if the new version was perceived as buggy and the previous version was considered stable and perfectly functional.

It was during this time that the notion of enterprise licensing came to the fore, with large software companies selling software “by the seat” with annual support and maintenance contracts.

Software piracy and licensing

Licensing became a big flash point. Software piracy soon became an ongoing battle between vendors and hackers. Smaller businesses needing more seats often “massaged” the number of installations at their offices to keep licensing costs down. This led to the use of dongles—a hardware stick that had to be plugged into the computer for the software to work—as well as license servers and software that had to “phone home” over the internet to start up. These methods, of course, were not very customer-friendly. 

Some software companies quietly tolerated piracy, figuring that the more their software spread—even illegally—the more legitimate sales would follow in the long run. The argument was that if students and hobbyists pirated the software, it would lead to business sales when those people entered the workforce. The catchphrase here was “piracy is cheaper than marketing.” This was never an official position, but piracy was often quietly tolerated.

In the end, the version release system led to peaks and valleys in revenue, as well as a bit of, ahem, sleight of hand with the definition of “sold.” Was the software sold the second it left the warehouse, headed to a retailer? Or when the customer paid for it at the register? It became common to “pump the channel” with boxes late in a financial quarter, then return the software after the first of the month, next quarter’s numbers notwithstanding. The dreaded Sarbanes-Oxley Act was motivated in small part by this practice.

The true value of software

Of course, the real value wasn’t in the physical products shipped, but in the actual bits and bytes that ended up in the memory of the computer. I remember a Usenet discussion (OK, argument) with a guy who complained that he had spent $299 and all he got were three lousy floppy discs. He remained unconvinced.

Over the years, the boxes got thinner and the documentation went onto the Internet. For a time, though, “online help” meant a *.hlp file on your hard drive. People fought hard to keep that type of online help well into the Internet age. “What if I’m on an airplane? What if I get stranded in northern British Columbia?”

Eventually, the physical delivery of software went away as Internet bandwidth allowed for bigger and bigger downloads. And it’s probably a good thing. I remember installing WordPerfect for Windows from 25 3½-inch floppies. I suspect some software packages today would have to be delivered on multiple DVDs!

But of course, things have changed, and today we rarely think of “installing software.” While I feel a certain nostalgia for the famous blue installation screens, it’s nice not to have to worry if I have enough disk space left to install that cool new tool I downloaded off of AOL. 

It took a while to get here, but today, software is almost universally delivered via the browser or some form of a package manager. We either run our applications in Chrome, or we install them with tools like HomeBrew, Chocolatey, or apt. 

And much of the software that is delivered this way is open source. Open-source software had a challenging route to the mainstream. Suffice it to say that entrenched commercial software companies didn’t take kindly to having to compete with free. But the case for open source was compelling, and businesses figured out ways to make money with it, mainly by selling premium features and support for the basic free product. 

The rise of SaaS

Much of that open-source software became the foundation for the Internet. It naturally followed that software as a service (SaaS) became the dominant model for delivering software, and we normally pay for that on a subscription basis. 

SaaS has many advantages over the physical delivery model. The obvious one is no more boxes shipped in trucks—software just appears on your computer with a few command-line incantations. Subscription-based sales smooth out the revenue for software companies, making finances more predictable. Bug fixes and new features are delivered immediately after being tested and approved.  Because the hard work is now done server-side, client computers no longer need gobs of processing power, memory, and storage space, and can be much smaller and lighter. These days, I do most of my work on a Chromebook.

But SaaS too has interesting economic implications for software companies. The marketplace generally expects a free tier for a SaaS product, and delivering free services can become costly if not done carefully. The compute costs money, after all. An additional problem is making sure that your free tier is good enough to be useful, but not so good that no one wants to move up to the paid tiers. 

Artificial intelligence makes this equation even more complex. AI takes a huge amount of processing power, and the processors themselves are scarce and can’t be manufactured fast enough. The electricity requirements are so great that companies are exploring building dedicated energy sources such as small modular reactors or on-site microgrids to power all those GPUs. Providing all of that with a free tier might be a stretch.

And even the paid tiers have limits today. For AI companies in particular, instead of a month of service, customers now pay for a limited amount of “tokens,” which have become a rough approximation for processing time. 

You can see how the economics of all that would be, once again, challenging.

From floppies to cloud credits

Making money in the software business is challenging. Some companies have done it really well and today are valued in the trillions of dollars. Even some individual developers, like my shareware hero, Nico Mak of WinZip fame, are probably comfortably retired as a result of their shareware success. Over the years, the notion of “owning software” has migrated to the idea that one pays for access to vast computing power that can be delivered to any browser. 

The economics of software have always been a bit peculiar because the product is maddeningly costly to design and produce, yet incredibly easy to replicate and distribute. The years go by, but the problem remains the same: how to turn ideas and code into a profitable business? We have changed the packaging—from floppies to cloud credits—but that difficult challenge remains the same.

Maybe that is the secret truth here. Software keeps changing, but the economics never really do.