When we work with our app development clients, we find that they often want to get to a solution as quickly and cost-effectively as possible. And we want the same thing—but not by letting the quality of our work slip.
Sometimes clients ask us why they should spend the time and budget for that higher-quality code. Isn’t “good enough” really good enough? We don’t think so.
We want to ensure that we develop incredibly high quality code that delivers long-term value for our clients. And spending the time and money up front to ensure high quality saves time and money many times over in the long run.
In this post, we’ll take a look at what high-quality code is and why having it in your product matters—to you, to your app and to your business.
Having “high-quality code” sounds like a good thing, but it is an ambiguous phrase. To explain why this matters to your pocket and your product, we need to first define what we’re talking about here. When we say “high-quality code” at Big Nerd Ranch, we mean a few things.
Your product is built using code, and we know that when we finish our work that it will need to be handed off to other developers for maintenance and continued development. That means that others will need to be able to easily pick up where we left off.
Because of this, we work hard to write code in a way that meets the goals and requirements of the product as simply and elegantly as possible. As we write our code, we document it with embedded comments so that other developers who read it in the future can understand what we wrote and why.
Even after we complete our work together, it’s pretty likely that you’ll want to build upon your product in the future. Maybe you’ll need to support an expanding user base, or to add new features. We understand this and always assume that your app will need to continue to grow and change.
As a result, we write the code for your app in a way that ensures the structure is sound. Your app will be built and organized in a way that allows it to scale. You need a solid frame to build on into the future, not a house of cards that will eventually collapse.
You may want new features along the way that weren’t anticipated. Problems we thought we would solve one way may need a different solution than originally planned for. This kind of learning and pivoting toward the best approach is not only inevitable, it’s vital.
That said, a natural result of this process is the accumulation of what is called “technical debt.” Put simply, it is the pile of inconsistencies that accumulate between existing code and newer code that’s been written as changes are made to the app.
And it’s called debt for a reason: it has to be paid at some point. The longer you wait, the more it costs to resolve—often much more, in both time and money.
There are times where you have to make some trade-offs about how quickly technical debt is addressed, but you should be cautious about putting it off. Think of technical debt as sludge: the higher it piles up around the code, the longer it will take you to make updates and add new features later. An important part of building high-quality code means resolving technical debt often, in order to keep building on top of your codebase foundation as fast and easy as possible.
So if an app works, isn’t high-quality code just developer preference and unnecessary polish? The answer is no—it actually matters to your product and business:
The tl;dr here is that having high-quality code in your app actually saves time and budget in the long term and gets you an overall better, more sustainable product.
Sure, it takes more time than cranking out something that “just works”—but that’s usually the case with quality products. Together, we can work with you to make smart decisions to meet your business needs and to ensure we build you a sound, healthy product ready to grow into the future.