Discover the hidden costs of new technology and gain essential insights for non-technical founders to make informed decisions.

15 November 2024

---

tl;dr. Your initial development costs will only be about 20-25% of the lifetime engineering cost of your platform. Sustainable technology requires ongoing investment.

You’re in an Hermès store standing in front of a Birkin Bag. You know the origin story where Jean-Louis Dumas met Jane Birkin in the seat next to him on a flight from Paris to London, and her complaining she couldn’t find a bag suitable for a young mother like her.

You also know these luxury bags regularly sell at auction for significant 5 figure amounts. But you’re revelling in the quality of the workmanship, trying to justify it to yourself.

One thing you’re not thinking about is it getting damaged or breaking. At this price you’re going to treat it like a precious snowflake and keep it like new.

You might be surprised to hear that the people at Hermès don’t think of their luxury product as precious. In fact, former CEO Robert Dumas-Hermès distilled the company’s mission as “luxury is that which can be repaired”, backed up by their 15 dedicated repair shops.

But what about technology?

The era of ‘there’s an app for that’ brought about a new type of software entrepreneur that’s less technically minded than before. There was a time where all you needed was a couple of dedicated engineers working out of a garage, but today it’s not uncommon for the ownership team for a startup technology company to feature no technologists.

This has been great for the diversity of industries we see technological solutions targeting, but not having spent time building technology can lead to blind spots.

The observation that all software eventually works, and all hardware eventually fails, underscores the preconception that only physical objects experience wear, and leads to underestimating the financial burden required to keep systems online.

There are 5 things that require investment to keep your software online:

1. Bugs.

Software development is complex. Really complex. As a result there will always be bugs in newly created software, and over time they will be discovered and fixed. You could choose to assign a large enough portion of your budget to quality assurance prior to launch to reduce the probability of errors to as close to zero as possible, but even the software keeping planes up in the sky can struggle to pull this off.

Assuming your customers’ lives aren’t dependent on your new platform, you’ll accept some defects at launch. This allows you to assign enough budget to add features that your customers will love. Then you’ll spend years fixing these defects, especially as you add new features, with exponentially less budget required to do so over time.

2. Fault tolerance.

The early versions of every system, whether it be mechanical, electrical, or software, require careful attention of the user. The new system’s novelty makes the inconvenience of having to operate it attentively a deal worth making.

But as your system becomes more familiar to your growing customer base you’ll see users break it as a result of not following the instructions. This user error will be experienced by them as defects that they conflate with actual defects, and if it causes enough drama you’ll modify the system to handle the user error.

This will be frustrating, as your customers won’t see the work as valuable, instead feeling that your system should have always worked that way. Which can lead to calling this process ‘idiot proofing’. I have significant disdain for this terminology as it demonstrates an arrogance towards your customers that will ultimately affect your bottom line.

Alternatively you’ll just ensure your users understand their loss was caused by their error. This might sound extreme but gas stations have done exactly this, instead of modifying their diesel pumps so that they don’t fit into a gas car.

3. Security.

There are bad people out there. Those bad people spend a lot of time trying to exploit your software, or more likely the frameworks use to build it, and the operating system it runs on. As exploits are discovered you will have to pay someone to modify your systems to protect you.

4. New functionality.

You know the least about what your customers want from your software early on, when you’re planning what to build. Once you’ve launched and received both implicit and explicit customer feedback you’ll really start to see where the opportunities are. This can mean small changes, like moving buttons around, but it can mean adding a new feature that costs more than the original prototype.

5. Dependencies.

Your software was built by combining third party code libraries. These can be relatively trivial helpers that manipulate text input, but also include large and complex frameworks that manage data and the display of what’s shown on screen.

The providers of those third party code libraries face the same pressures as you to evolve their software, and as a result they release new versions with new functionality, and may eventually disable the version you rely on. When they do, you’ll have to pay someone to update your system to work with their new version.

Exceptions.

If your software exists in a vacuum it will continue to work without the need for ongoing investment. It’s common to find antiquated tech in established businesses due to an attempt to sustain these vacuums.

For example, my mechanic friend has a computer running Windows 98 because software he relies on hasn’t been updated to work on newer operating systems. And you’ll often find a similarly stale computer running large CNC machines because the latest version of the CNC software which runs on modern systems requires a paid update that can cost many thousands of dollars, while adding negligible value.

If you have one of these antiquated systems, ensure it’s not connected to the internet as it is a prime target for hackers.

How much will this cost?

All of this brings me to the mistake I see inexperienced non-technical founders making most often. They have an idea for a business that’s based on a new technology. They gather pricing to have a third party build the new technology, or maybe calculate the staffing costs to launch their new system. The excitement is infectious as they realize that if they pull together resources they can afford to make their dream a reality.

But as you’ll now realize, launching the system isn’t the finish line, it’s the start line.

A good rule of thumb is to assume the build cost will account for 20% to 25% of the lifetime engineering cost of your new platform. It’s important to note that this doesn’t include hosting, so add your monthly server costs, and don’t forget a marketing budget big enough to acquire enough new customers to hit critical mass.

It’s painful having to pay for your software’s longevity, but over time the system will become yours, increasingly stable and profitable, with an added bonus analogous to Zen and the Art of Motorcycle Maintenance.

Like Hermès, rather than aim to achieve the impossible to make the perfect thing that will never age, make something worth the time and money to repair it when needed.