Why ‘Good Enough’ Isn’t Good Enough for Our Clients
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.
What Does “High-Quality Code” Mean?
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.
High-Quality Code is Easy to Read by Other Developers
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.
High-Quality Code is Built for Scalability
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.
High-Quality Code Manages Technical Debt
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.
But Is It Really Necessary?
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:
- You save on time, money, and effort in the end. Caring about code quality now saves you money over the life of your app; rather than investing large chunks of time backtracking to fix things, you spend a little time along the way.
- You have a product that is easier to expand upon down the road because we built a solid foundation.
- When we finish our part in your product, any developers that work on it next can pick up where we left off, with minimal effort.
- You have a product that is healthier and you spend less time and money thrashing with untraceable bugs or figuring out how to make updates.
- You have fewer mistakes or errors in your codebase, because code written had multiple sets of eyes on it before ever becoming part of your product.
What’s the Short of It?
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.