Paying at the Point of Value

Les Sacres YeuxProbably the number one question I still get about open source software is “how can you make money if you give the software away free”. The thing is, I don’t believe that’s what is going on. Instead, developers in communities around free software in a commons are working on the development side of the glass to create flexible value on the customer side of the glass. I wrote this essay long ago in another place, but it still seems relevant today.

The Customer Side of the Glass

The role we play in an activity shapes the way we understand it. For example, consider what happens when I get my car serviced. The folk at the garage take the keys, go to the other side of a big window and get to work on the service process while I sit in a comfy chair nursing a cup of coffee and worrying about how much it will all cost. We’re both “getting the car serviced”, but what that means differs hugely depending on what side of the glass we are.

On the oily side of the glass, it’s all about quality, safety, parts, engineering, problem-solving, teamwork, participation. A group of experienced professionals is working to make sure my car works just right.

On the coffee side of the glass, it’s all about waiting to drive, when it will be finished, how much it costs and – most importantly – where to get more coffee.

I think “open source” is like this too. The “glass” divides software deployers and software developers. One side of the glass it’s all about participating in a community of code, innovating, contributing and other developer issues. The other side of the glass it’s all about value-for-money, freedom of choice of supplier, low exit costs and other business issues.

This is not to deny that some people are capable of “home servicing” – but for most folks there are two worlds that we should strive to avoid confusing. It’s this that some people miss when they say things like “not every CIO cares about having access to code or hearing about social infrastructure and ages of participation.”

It’s “open source” on both sides of the glass but we misunderstand one another if we use the concepts and values from the wrong side of the glass when we discuss what that means. Just because we reject the arguments that motivate “the other side” it doesn’t mean we don’t need open source software ourselves.

Paradox Lost?

What’s really happening is that the point of payment has shifted, like it did in the late 1970s. “Software Market 1.0” involved selling a mainframe-ish computer and shipping it with all the software included (usually with full source code). When I got my first properly paid job in the computer industry back in 1982 (I’d already been programming for a while by then), there was already a shift in progress, from shipping the software with the computer to selling the software separately from the computer, creating “Software Market 2.0” – the Great Unbundling as my colleagues at the time called it.

The open source revolution of the first decade of the 21st century marked the emergence of “Software Market 3.0”, where the payment for software is made not at the time of acquisition but at the time the deployer starts to see value. That’s typically at the point where the software goes into production, and what people do at that point is pay for the essential services – bug fixing, patching, telephone support, on-site support and also harder-to-see services like evolving the software – that either can’t be home-grown or are cheaper bought from a supplier.

In Software Market 3.0, it’s not so much that the Freedom of the software leads to the freeness of the software – although, if you have the resources in-house, you never need pay anyone outside (that’s a big “if” by the way). In Software Market 3.0, everything is available at no charge to somebody because of the need for developer freedom, so it’s tempting to think it’s all available to everyone at no charge – but it’s not.

The real point is that the deployer is liberated to pay just for the things that result in value, when they need it. It also opens up new ways of delivering the value – online, as a utility, by subscription and more. Open source on the deployer side of the glass is the shift to payment at the point of value instead of at the point of acquisition of the bits.

Paradox Regained

As Stephen O’Grady pointed out long ago, there are some customers who know value and will pay however you structure the offering, there are some customers who might pay if they discover value and there are some customers who won’t pay whatever you do. In the world of Software Market 3.0, those who will pay will still pay because the value is still there – they just pay later.

But more to the point, some of those who might pay get to discover the value because now they can see the software in action and find the value rather than have to pay to find it. Once the software is in use in both categories, it can spread easily because there’s no licensing barrier to try innovating across the business.

And the others? Well, they still won’t pay so we’ve lost nothing if they use the software we’re promoting, but in deploying they will have to get that value somehow so will probably engage with and enrich the community on the developer side of the glass somehow. Net gain? More customers and a richer product, by apparently giving away the software. A paradox until you dig deeper.

2 Responses

  1. […] As Simon Phipps pointed out in his article titled “Paying at the Point of Value“: […]

  2. […] project, and move to a commercially supported version when you decide it’s time – paying at the point of value, as Simon Phipps has put […]

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: