Have you heard of Murphy’s Law?
It’s the saying that goes “Anything that can go wrong, will go wrong.”
It happens a lot in software development, and particularly in custom software development.
Unfortunately, custom software SNAFUs are far too common, and can happen for a wide variety of reasons.
Often it has to do with hiring software developers lacking the necessary skills and experience for the job, problems in communication, or clients who don’t quite know just what it is they’re looking for in a custom software solution.
So why then would anyone need custom software, when it seems to prone to problems, delays, and errors?
Think of Custom Software as Being Similar to Buying a Tailored Suit
If you’ve ordered a bespoke suit before, you’ll know that while it costs more, it fits you like no off-the-rack suit can.
In the context of business, the right fit can be the difference between increasing productivity and turning a profit, or being inefficient and running at a loss.
This is especially true for custom software development.
Custom software development offers the following core benefits:
- Custom software is tailor-made to your specifications and business needs. It’s common for companies to buy licenses from software vendors, only to find out the product isn’t a good fit.
- It’s easy to scale custom software. With off-the-shelf packages? Not so much. When your business grows and your software needs to scale, you can always hire a developer on a contractual basis to maintain the application.
- Custom software is less messy. Off-the-shelf software usually comes with features you don’t need, some of which may only cause issues. In contrast, custom software solutions will only have features that you actually need.
Here’s an even more in-depth comparison of custom and prebuilt software solutions:
So yes, custom software has a lot going for it. But as I mentioned earlier, the process of building applications specifically designed for your business is rarely a smooth process.
As Levi Strauss found out in 2003, major IT undertakings present significant risks. The company reportedly lost $200 million after investing $5 million in a failed overhaul of its IT infrastructure, a huge blunder that forced the CIO to resign.
In this post, I go through a number of common mistakes and issues that can, and probably will, happen in the custom software development process.
Problem 1: Thinking of Custom Software as a Product
From a business standpoint, it’s certainly easy to think of custom software as being like any other software product.
But there are some problems with that view.
For starters, custom software development isn’t something you can buy off the shelf like a pair of socks, a phone, or a carton of eggs.
Instead, think of obtaining custom software as a process or, better yet, a journey.
Unlike with prebuilt software solutions that work out of the box, custom software development takes a holistic approach to your organization’s technology needs.
Developers take their time (or at least they should) to provide feasible software options and build custom systems with the best likelihood of improving your organization’s operations.
For example, at Worthwhile, the software development process goes like this:
As you can see, our process is one that requires a lot of time and effort. The development step is only one part of that process.
It’s important to make the distinction between off-the-shelf and custom software, because procurement staff often rush the development process, defeating the purpose of acquiring personalized software in the first place.
Problem 2: You Don’t Own Your Software’s Source Code
Source code. It’s a thing. Have you ever thought about it, or more importantly, who owns it?
One of the biggest mistakes I see many companies make when working with custom software developers is failing to secure the source code as part of the software project.
Think of it as having a contractor build or designed your house, but refusing to give you the blueprints afterward.
When a software solution’s source code isn’t part of the deliverables in your contract, you put yourself at the mercy of the developer, requiring their help—and only their help—when making any changes in the future.
Preventing this issue should be simple—be sure to go over your contract with a developer before starting the project and see to it that you own the source code. Make sure the contract for the project clearly delineates how this works.
If you don’t own the source code, don’t sweat it. But in this case, you should make sure that you can retain the services of the original developers for troubleshooting post-launch.
Problem 3: Getting Carried Away by Arguments for and against Custom Software
When it comes to custom software, CTOs usually have two opinions early on: They either support custom solutions fervently, or are vehemently against it.
Either way, you lose objectivity.
Every organization’s needs are different. This means there’s always a time and place to use off-the-shelf software.
Whether you like the idea of adopting custom software or not, always be sure to step back and take a long-term view of the situation.
- Are your competitors using custom software?
- What problems and successes have you noticed with their implementation of custom applications?
- What competitive edge will a custom application give you?
In other words, try to take a neutral stance as much as you can before making any decisions. You want what’s best for your organization, not what others think is best.
Problem 4: Your Custom Software Project is Taking Too Long
As a rule of thumb, when a developer provides an estimate for the duration of a software development project, you’re offered an ideal target time, not so much a prediction.
For example, when your developer says, “Give us half a year to get it done,” it often means one of three things:
- We’re giving you a six-month estimate because it’s what you want to hear and we really need your business.
- We’re going to try and get the project done in six months, even if our experience with projects of similar size says otherwise.
- We’re going to promise to do it in six months, even if we have no clue how because we’ve never worked on a project like this before.
If anything, this highlights the importance of both hiring a reliable developer, and having reasonable expectations of a timeframe for completing the project.
Problem 5: It’s Costing Too Much Money
For the most part, it’s hard to tell customers the exact cost of any given custom software project.
For starters, some expenses may come up in the middle of the development process.
Likewise, some part of the project may also require detailed work at the last minute, affecting the length of time needed before you can declare it satisfactorily complete.
One way to get around this problem is to agree on a safe budget up front. Before signing off on a project, we can tell you if the budget you have is reasonable based on the results you want.
If it’s a tight budget, we can recommend prioritizing certain features, that way you can still get great results on the most critical areas of the application.
Problem 6: Failing to Define and Manage Expectations
Often, what makes custom software projects devolve into frustrating endeavors is failing to be on the same page with the developer from day one.
If have any experience signing up a custom software developer in the past decade or so, you’ve probably come to appreciate the importance of being extra specific.
Indeed, the strength of custom software packages comes from having it specifically tailored to your organization’s needs, a process that works only if you’ve submitted all of your requirements for the software project.
You need to be specific about your final application’s appearance, functions, and interface among other factors. Being specific also controls the project’s overall cost, which can fluctuate with the addition of what seems to be minor requirements.
Problem 7: Scope Creep Caused by Last Minute Changes to Requirements
Your custom software project is chugging along nicely, and your developer seems to be doing fantastic work.
But all of a sudden, you realize that the outlined requirements missed one or two critical features needed by your business. Perhaps you failed to be specific about your source data.
Now all work has to stop, with the developer taking note of the change order, and possibly changing the contract.
You’re not happy with the added cost and unexpected delay, and your developer is unhappy with the detour and having to go back to the contract.
Unfortunately, these things happen—all the time, in fact.
Instead of setting hard requirements, I would suggest a more agile approach, one that takes into account a customer’s goals and ranking them according to priority.
This way, any addition of last-minute requirements won’t derail the project, so long as it’s consistent with the project’s goals.
Problem 8: Adding More People to the Development Team
Many managers of custom software projects make the mistake of viewing software projects as being similar to assembly lines.
This perpetuates the belief that if things are falling behind schedule, the best solution is to throw another body at the project.
But adding more developers to speed up the project doesn’t necessarily work. In fact, it might just slow down the project even more.
The more complex a project is, the more training a new developer will need to catch up to speed.
This also means the customer might incur additional costs to compensate for delays and addition of developers.
Even if you’re working with a software development firm, you’ll want to make sure it has standards and best practices in place that allow for knowledge transfer and efficient onboarding. That will protect you against developer turnover.
Problem 9: Communication Breaks Down
Many organizations that pay for custom software development assume that all they need to do is meet with the vendor, pay for the cost of the project, and wait for the finished project.
This is a huge mistake.
As I mentioned above, custom software development is a journey, one that both you and the developer will have to embark on together.
Great software development agencies want to build a close customer-vendor relationship, treating communication as a two-way street.
Any firm that tells you, “Leave the work to us, and we’ll let you know when it’s done,” or something to that effect, probably isn’t worth your time.
Communication has to be consistent, with the developer constantly trying to form a comprehensive understanding of how the software’s end users behave and use the application.
In other words, you need to be involved in the software development process. And this means knowing from the beginning how you’ll communicate and how much time you can expect that communication to take.
Problem 10: ZERO Risk Management
By now, you’re probably beginning to understand just how risky custom software development is.
The important thing to remember is for both developer and customer to sit down and create a risk management plan.
It’s a platitude, but prevention really is better than cure.
Listing down the things that could possibly go wrong (which is what this guide is for, by the way) at the beginning of a project, with possible solutions for each scenario, will help reduce damage or downtime should the worst happen.
Problem 11: The Software Isn’t Working as It Should
Let’s get one thing out of the way: there’s no such thing as “perfect” software. Problems are especially common when upgrading legacy software.
Unfortunately, issues like bugs and glitches are inevitable with custom software, more so for large-scale solutions.
At Worthwhile, our goal is to reduce the incidence of problems and their impact on your business, but we also know that things will go wrong—again, Murphy’s Law.
But more importantly, we want to identify problems as early as possible to reduce costs. One IBM study shows that the farther along the development process a glitch happens, the more expensive it becomes to fix. This graphic shows how the orders of magnitude work with this.
This is precisely why it’s important to draft a risk management plan in the first place.
Problem 12: Being too Eager to Add Bells and Whistles
Both developers and customers are guilty of this.
A major mistake when creating custom software is building a solution that’s too complex for the organization’s needs.
As cool as it may seem to have nifty features and other extraneous bells and whistles, less is always more. That’s especially true in the beginning.
Always design software for the end users. As much as possible, ask them what they want the software to do, rather than making assumptions.
Great developers know that the hallmark of great software is when it just works, with users requiring little training to use it.
Problem 13: Hiring the Wrong Custom Software Developer
I’ve heard my share of horror stories about companies ending up hiring the wrong developers.
The sheer scope and gravity of a custom software project obviously makes it imperative to choose the right developer.
Unfortunately, many organizations sometimes choose the first developer they see, or worse, choose one with the lowest rates.
You get what you pay for, so it’s vital that you hire a custom software development firm based on their ability, repertoire, and track record of clients.
Problem 14: Poor Back-end Functionality
Back-end functionality in software refers to features that aren’t visible to users.
CIOs naturally want to get the most bang out of their buck, an attitude that encourages developers to focus their efforts on the application’s most visible (front-end) features—those most likely to wow users.
This leaves the other “less important” stuff on the backburner. And because issues in the backend don’t appear right away, they usually turn into a serious problem well after launching the software.
It’s no surprise then why unscrupulous developers use this tactic to chain customers to their services for as long as they use the software.
Problem 15: You Got Hacked
Security is a serious concern any developer should be aware when build web-based software.
Content management systems for example, need to be secured by robust encryption protocols.
Generic web hosts rarely offer proper advice on backing up this data, with the majority relying on FTP for file transfers, which are notoriously susceptible to breaches.
Wait, Does All This Mean Custom Software Development Isn’t Worth the Trouble?
Don’t get me wrong. I’m not counting down the issues on this list to scare you from investing in custom software.
I’m doing it so you can manage your expectations and adopt the appropriate mindset when hiring a custom software developer.
Fortunately, there are several keys that can make the custom software development process as pain-free as possible.
- Hire great software developers (or an agency) – I cannot stress this enough. Choose developers with the right skills and a proven repertoire.
- Outline a code of ethics – Introduce your potential software developers to your code of ethics. What do you expect from software developers? What kind of autonomy do they have? Do you observe any specific management practices they need to know about?
- Choose a developer with vision and values – At Worthwhile, we are committed to using our craft to create a better world, asking customers the best questions to produce great work, keeping our word, and setting ambitious goals and doing all that we can to deliver delightfully.
- Choose an agency over a freelance developer – Hiring an agency rather than a developer is usually the best choice. Why? Hiring an agency gives you a safety net—more developers, more talent, more troubleshooting, testing, iteration, and help launching the software. Depending on a single developer for a custom software is a problem waiting to happen.
- See if the developer is familiar with Agile methodology – Agile may seem like a buzzword in programming circles, but it’s a philosophy Worthwhile has found great success with using.
Agile software development allows us to develop a wide range of high-quality software solution consistently and frequently by understanding our customers’ business and users, and developing relationships that last on a long-term basis.
Different organizations have different needs. When evaluating potential custom software solutions for your company, ask yourself what your vision is for having custom software. What do you intend to do with it? How will it impact your organization?
If you need custom software, always be aware of the risks of building custom applications.
Most, if not all, of the issues on this list can be mitigated by choosing the right software developer—one with experience, ability, and a strong track record.