Almost everyone has heard of Technical Debt by now, but Functional Debt exists too.
Let me tell you about Functional Debt, what it can do to you if you’re not careful, and how to keep it at bay.
Because this isn’t something wildly talked about yet, the definitions may vary, but I’ll share mine here:
Functional Debt is the direct result of previous business decisions that causes a degraded ability to address current or future business goals.
– Matt Eland
Let’s unpack this definition.
By degraded , I’m referring to anything that slows or prevents the business from making improvements or changes in the way they’d want to.
By direct result I’m talking in particular about intentional choices made by the business in some point in its existence. Additionally, choosing to “go fast” and not make drawn out choices can be a choice in of itself as this can constrain future changes as well.
Let’s give a hypothetical example:
Let’s say you’re a software startup with a small web application. You’re growing a user base and starting to get low levels of payment and usage. Your sales team finds a big opportunity, but you need to add some new features to your entity handling that will satisfy their business needs.
You make the changes, take the money, keep the lights on, and implement the feature. In doing so, you’ve made a few decisions about how your software should work and behave as well as your general strategy for handling customer-specific needs.
Most companies don’t understand the impacts of the functional debt they take on through early decisions, but let’s follow this company further.
We fast forward a few years in our scenario and the company is growing and doing well. There’s a decent user count and variety, but you’ve yet to truly “hit the big leagues”.
Suddenly, sales announces a large potential customer is interested but wants a significant change to how the software works. Their change conflicts a little with some of the decisions you’ve already made and how your business rules work.
This is where your past decisions are converted from risk to actualized functional debt. Here you are forced to make one of a few different choices:
- Rework the old logic to work how the big customer wants it, potentially displeasing your user base in the process
- Make your logic more and more configurable to meet a variety of usage scenarios
- Fork your codebase and offer a dedicated version just for the large customer
- Walk away from the sale (and likely any other sale like it)
Every single one of these choices has negative consequences.
If you adapt an existing system to work in a way contrary to its initial design, you could forget to adapt critical pieces of logic and introduce subtle bugs. That is to say, revising the purpose of a feature incurs a quality risk.
If you add configuration options, your system becomes harder to use and maintain. This is because you have to maintain database columns for configuration choices, maintain the UI to configure these settings, and maintain code that can handle things in a number of different ways. Testing all paths becomes exponentially tricky as you add to the configuration options the system has.
Forking or branching a codebase is a viable solution. However, this can be something you regret as you now need to implement new features in two codebases. If you want to pay down tech debt, you now have to pay it down in multiple places.
Walking away from a sale may make the developers cheer, but it also doesn’t pay the bills and can represent a huge missed opportunity to explore new market segments related to that customer’s needs. That said, it’s still often worth doing.
Another way that functional debt can impact a business is if you want to innovate new capabilities. For example, let’s say a new competitor adds a minimalist user interface and very flexible and dynamic capabilities. Your product that serves a wide variety of users may not be easy to modify to offer the same degree of flexibility.
Here’s the hard to accept part: the reason it becomes hard to adapt an old product is at least partially because of the business decisions you made in adding functionality in order to get to the point where you are today.
So, what can we do differently?
Well, first of all, start saying no. I’m not saying you say no to most sales opportunities or even most feature requests.
I’m saying that when entertaining new features to add to the software, you default to saying no.
You should not add a feature unless the short and long-term benefits outweigh the estimated short and long-term costs.
This no can be to external customers or potential customers or to internal employees advocating for features.
For example, say a designer wants to make the application support themes other than a dark theme. Her justification for adding these is that people will like them and the time required is very low.
Let’s say your designer doesn’t have a lot else on her plate at the moment. She should make those changes, right?
Well, possibly, but let’s look at the longer term. Adding the ability to theme the site as a whole puts new theme support work on designers and developers as they add new pages and controls. Additionally, quality assurance must test using the different styles.
Finally, the styling support is another feature that a replacement system will also need to make if they want to stay in parity with the current logic.
Okay, so what if you haven’t said no? Is all hope lost?
Probably not, but it might be time to retire a feature or two.
Specifically, what you can do is introduce a newer system of doing things – one that has lighter rules and more flexibility, but less initial features. You design this new system with your new needs in mind as well as your old needs (if you want to continue to support the old system) and a way for people to try out the new motif and potentially migrate their data over.
For example, let’s say you have an editor component that you offer to end users. People are used to the original editor, they can work with its functionality, and they have some content written using it.
You need to add on new functionality that’s just not possible given the choices made in the original editor, and so you create a new editor type and allow users to choose which editor to use when creating new content.
Over time you develop a pipeline that will automatically convert users to use the new editor instead of the old one. You then give people that path for awhile until all functionality from the old editor is now present in the new editor as well.
Once the new editor is ready to replace the old, you announce a cut-over date some time in the future. Once that date arrives, you convert to the new model, and then get rid of the old model.
Hopefully the replacement implementation will be built based off of a more mature understanding of the organisation’s needs and prospects and will represent a smaller functional risk to the organization.
Functional Debt is a term I mistakenly thought I had coined a number of years ago.
It turns out that I am not the only person to have thought about this topic and come up with this term.
Here are a few articles by others that I would recommend looking into if you’d like a second or third opinion on this topic:
- Every Feature Considered Harmful – Michael Dubakov
- Functional Debt vs Technical Debt in Software Development – Roman Predein
If you have a different definition or criteria than mine, I’d love to hear your take, especially if you can provide examples of functional debt to support it.