InsightsPoint of View

The economics of software ownership

What an owner takes on when a useful application becomes part of the business

An equipment-rental return and readiness area with organized assets, operating records, and tagged equipment keys.
By
Cam Myers
Content type
Point of View
Reading time
6 min read
Status
Author’s perspective
Topics
Ownership & Economics

In brief

  • Creation cost and the continuing responsibility of ownership belong in the same decision.
  • A portfolio of small applications can create large costs between systems.
  • Fit, support, recoverability, and the ability to change direction affect the investment.

The argument

The first version of an application may take an afternoon. The company might depend on it for the next five years.

Those two time frames belong in the same decision.

AI coding tools make it possible to explore custom software with less initial effort in many situations. A quoting tool, inventory lookup, or customer follow-up application can become practical where a large development project would never have been approved. That expands the choices available to an owner. It also makes it easier to accumulate software before deciding who will be responsible for it.

An application becomes part of the business when people organize work around it. Customers expect its promises to be honored. Employees stop maintaining an alternative. Other systems begin relying on its records. Its importance can grow much faster than its original budget.

The decision underneath

What will the company own—and be responsible for—after launch?

Buy the capability over its working life

Consider an illustrative midsized equipment rental company in the northeastern United States weighing a custom quoting application against a commercial system. The custom version costs $8,000 to build. The commercial product costs $900 a month. Comparing $8,000 with $10,800 a year makes the custom option look attractive.

The comparison is incomplete. The company needs to consider hosting, support, changes to connected systems, backups, security, staff training, and eventual replacement. It also needs to examine the commercial product's implementation charges, limitations, price changes, and the manual work required to accommodate it.

Either choice can win. Custom software may handle pricing rules that matter to margin and that the commercial product cannot represent. A supported product may cover a routine need more reliably than a small internal application. The answer depends on the capability the business needs and the obligations each option creates.

The owner should ask what happens when something changes. A tax setting is updated. A supplier changes its interface. A customer needs an exception. The employee who understood the pricing formula leaves. Which changes can ordinary staff make safely, and which require a developer?

Software that fits perfectly today can become expensive if every ordinary business adjustment requires technical intervention.

The applications become a portfolio

The harder issue appears when a company has fifteen small applications, each with a sensible justification.

One quotes work. Another sends delivery notices. A third calculates commissions. Several exchange customer records. Each is inexpensive in isolation, yet the combined arrangement may depend on conflicting definitions and invisible connections.

Imagine the customer changes a delivery address. The quoting tool has the new address, dispatch has yesterday's copy, and the notification tool sends a message using a third record. Every application can be working as designed while the truck goes to the wrong place.

The cost lives in the relationships between applications. Adding one more tool may require changes in several others. A shared dependency can also create a common failure: five useful applications become unavailable when the same hosting account or identity service fails.

This creates an important ownership question. Which information should be shared and authoritative, and which functions should remain separate?

Customer identity, permissions, and agreed financial definitions often deserve common treatment. A narrow calculation or a temporary analysis may be better left independent. Joining everything together adds coordination costs; leaving everything separate creates reconciliation costs. The architecture should make that trade deliberately.

I would rather see a small collection of clearly owned capabilities than a long list of applications whose responsibilities overlap.

Match the obligation to the consequence

A tool that helps a manager explore next month's demand can tolerate a different standard from one that commits today's prices to customers.

The second tool needs greater assurance because its errors create external obligations. The company needs to know which version of the price rules produced the quote, who can change those rules, and how an incorrect quote will be corrected. It needs an alternative way to serve customers when the application is unavailable.

Google's published work on site reliability describes how repetitive operating work can consume the time needed for lasting improvements.[1] An owner does not need Google's infrastructure to recognize the economics. If the application requires constant rescue, its apparent labor saving may have become someone else's permanent support job.

Support time also competes with other valuable work. A developer maintaining twelve small tools cannot use those same hours to improve the company's most important system. That opportunity cost belongs in the decision even when no additional invoice arrives.

The appropriate answer is proportional. A temporary internal tool should not require the same operating machinery as customer billing. But a customer billing application should not inherit the standards of a temporary experiment merely because both were built quickly.

Preserve the ability to change direction

Custom software can reduce dependence on a vendor while increasing dependence on one developer. Buying software can provide support while making the company's data difficult to move. Neither ownership model guarantees freedom.

Practical freedom means the company can retrieve usable records, understand important business rules, obtain authorized access, and hand responsibility to another qualified person. A source-code folder is only part of that requirement. Someone must also understand how to operate the system and what the business expects it to do.

A small prototype has a different purpose. It can answer a narrow question before the company commits to owning a production capability. Will the pricing logic work? Can employees use the workflow? Does the new arrangement remove enough effort to matter?

Keep those experiments easy to discard. Connect them to live operations only after deciding what ongoing responsibility is justified. Otherwise a trial quietly becomes essential infrastructure without ever receiving an operating budget.

The ability to retire software matters as much as the ability to create it. A business should periodically identify tools that duplicate another capability, no longer serve a useful purpose, or cost more to support than they return. Removing one can simplify the company beyond the value of its individual hosting bill.

There is a strategic reason to build selectively as well. A capability deserves greater attention when it helps the company do something customers value and competitors cannot readily reproduce. Routine office work may still justify a custom tool, but its advantage usually comes from lower operating cost or a better fit. The owner should be clear about which return is expected.

Fit itself needs examination. A custom application can accommodate a distinctive pricing model, or it can preserve years of exceptions that nobody has questioned. Before paying to reproduce a complicated workflow, ask which differences create value and which merely record the company's history. Building around the second group can turn an avoidable operating problem into a maintenance obligation.

The prototype can help answer that question before the design hardens. Its value may be the evidence needed to simplify the business, even if the company ultimately buys its permanent software from someone else.

When I evaluate a build decision, I want a clear answer to what the company will own after launch. Who maintains the rules? Who notices a failure? Who can restore service? What would migration require? Which expense or constraint makes taking on those obligations worthwhile?

Cheaper creation can make custom software a better investment. The strongest investments use that advantage to secure a useful business capability at a manageable continuing cost. The owner should be able to explain the value of having it and the responsibility of keeping it working.

Source notes

Business examples and figures are illustrative and are not reported client results.

  1. Vivek Rau. Eliminating Toil. Chapter 5 of Site Reliability Engineering, Google. The application to smaller business software is the author’s analysis.

For the leadership team

In practice

  • Compare custom and commercial options over the capability’s useful working life.
  • Assign ownership of business rules, support, recovery, and connected records.
  • Keep experiments easy to discard and production capabilities possible to hand over.

Questions worth asking

  1. Which distinctive operating capability justifies the continuing obligation?
  2. Could another qualified person operate, change, or retire this application?

Weighing this decision now? Tell us what you are considering and we will say plainly whether we can help.

Discuss a software capability