Both Brian and I come at marketing and sales from a software development background, and we’ve been lucky enough to be asked for advice quite a bit over the years. I was talking to a friend about a sales issue he was having the other day when I got angry enough that I did something irrational. I tweeted.
Hi software companies can you please teach engineers how software purchasing actually works before you tell them to evaluate products? Thnx.— mrb (@mrb_bk) December 2, 2016
Some people were curious enough about what I meant by this pretty vague subtweet that I promised them I would write about what I meant. So here goes.
Why developers undervalue software
This isn’t exactly news, but one of the most challenging aspects of selling software to developers is that many, many, many developers think, no matter what it costs, that software should be cheaper.
There are a lot of reasons for this, but I’m going to cover the three that I have heard the most in my travels:
First, developers think they can build it themselves. The logic here goes something like,
“Wow, I can conceive of how I could make something that approximates this service by gluing some Open Source code together. Therefore, when I’m discussing the cost of this product with someone who spends most of their waking life working on it, I should just tell them that if they don’t lower their price, I’ll just build it myself.”
Needless to say, this attitude is neither valid or helpful. While it’s true that basic functionality of commercially available software could be cobbled together by a given developer, that’s not actually what you’re buying.
When you’re buying software, you’re not just buying software. You’re buying support, and innovation, and you’re buying the result of someone’s dedicated and focused time. You’re not just buying features. It’s worth keeping that in mind.
Secondly, it’s easy for developers to undervalue software because the market obscures the true price of software. How software companies get funded, how they spend money, and what “should work” and what “shouldn’t work,” sadly, are just not things that you can reason out from first principles. Developers have a tendency to want to see the world in a certain way — I know, I am one. I’ve also worked with plenty enough to know that it’s challenging for us to scratch below the surface of functionality and think carefully about the value that we get from software, not how much we think it costs to produce.
Venture Capital, crowded markets, advice fatigue, Hacker News, they all make it hard to see through the noise. Part of what we’re trying to do with Reify is to use our experience to bring a solid, clear voice about software marketing and sales to a harried, frenetic world. Stay tuned to see how successful we’ll be there!
Finally, developers often undervalue software because software sales and purchasing are unnecessarily complex. Many developers work embedded inside large organizations where they either have no say in software purchasing, or are poorly informed to begin with when they’re involved in the process at all. The bottom line is that the act of buying software is typically way more complex than it needs to be, and definitely way more complex than many developers think it is. In the typical scenario where your team is evaluating software, a lot can be involved after you say “yes” —
Competing products: some companies mandate that solutions be measured against competitors. That means that companies will be running multiple trials at the same time, even if they don’t need to be doing so.
Procurement: the procurement department at large organizations deals with the final stages of a deal, from contracts to financial terms. This takes time and costs both sides of the deal money. There are sometimes perverse incentives at play here, but at the very least, developers should understand how procurement works at their companies.
Your boss goes on vacation / You have a production fire you have to put out / Business plans change: I’m just trying to illustrate — it’s not all straightforward, for either party.
How this is costing us all money
There are lots of reasons why this issue is important to me. Besides the fact that I’m part owner of a software company, and consult other software companies on how to sell software, the pervasive undervaluing of software by developers is costing all of us money, and shrinking our piece of the pie.
When you’re a developer considering various products to purchase on behalf of your company, it’s important to remember a few things:
It’s not your money. The value of software to a whole team or company is different than the value you’d pay out of your pocket for yourself.
Price is based on the value that software provides, not how much you think it should cost.
Keeping the price of software down isn’t good for business owners, and it’s particularly not good for developers.
There’s a lot of talk around the startup world these days about how hard it is for developers and non-founders/non-early employees to get compensated fairly when a company does well. Years and years of developers being kept away from the table when deals are made has left us in a position where we don’t really understand what goes on when software is bought and sold. Developers tend to be underpaid relative to the value that they bring to their companies, and the more they know about how software purchasing and sales works, the better off they will all be.
If this article has intrigued you at all, and you want to know more, this talk by Michael Dearing about pricing is a great place to start: Michael Dearing | Pricing | Heavybit Pricing is sometimes thought of as a math problem but to Harrison Metal founder Michael Dearing, it’s a judgment…www.heavybit.com
This can all be yours
At Reify, we firmly believe that the domain of marketing and sales are not beyond the grasp of anyone. Coming from backgrounds as developers, we know what it’s like to get curious enough about how things work on “the other side of the house” to make it our full-time gig. Our new mission is to bring along as many of you as we can, and preaching the gospel of value-based pricing is one of the best places we could think to start.
Undervaluing software starts with a lack of understanding for the nuance of how the production, packaging, and sale of it works. This is kind of strange, for the obvious reason that many of us produce software ourselves, and would bristle at our own work being undervalued. It’s time for everyone who is a part of the production of software to understand the real value involved.
So developers: stop undervaluing software. Help everyone by looking past your knowledge of how software is produced to find the value it provides.*
We’d love to hear from you about how this meshes with your experiences of buying and selling software, and if you’re in the business and need some help, don’t hesitate to get in touch.
Yes, this also implies that people selling software should probably be charging more than they typically do. We’re happy to help with that too :)
The amazing Julia Evans made this comic in response the above post. She’s super amazing: