When it comes to outsourcing software development, you must be aware of the potential dangers that can come with it. Take a look at our don’ts of outsourcing your software development below.
Danger #1: You Ignore Outsourcing
Ignoring outsourcing isn’t a realistic strategy. We all know that outsourcing isn’t going away anytime soon. The use of outsourcing is growing rapidly. But here are some reasons why some choose to ignore outsourcing.
- You don’t know how to select an outsourced team. It’s tough to select a team -- there are many, many teams out there, and choosing the right one is a challenge.
- You think only a big project is worth the time and trouble. You may think that you can just hire a few engineers for your project. But as you’ll see shortly, this can really add up and bust your budget.
- You believe that all of your software must be developed “in-house” to get the best results. Sometimes this is true. Buy why do you believe that you have to develop your code in-house? Is it fear of the unknown due to a lack of experience with outsourcing?
- You overlook the slow ramp-up to build your employee team. How long does it take you to hire a team of engineers? Two or three months? That’s a long time to wait until you start to write your software.
- You overlook the high burn rate to support your employee team. Salaries are one thing. Then there’s the cost of benefits, officers, computers, and so on. Recruitment costs, benefits, and overhead can easily add 30 to 50 percent or more to employee salaries.
Danger #2: You Hire the Wrong Outsourcing Vendor
Maybe you’re only considering your friend’s roommate’s brother in Bangalore or his cousin in Kiev, but it’s a common mistake to look only among your immediate circle for resources. Similarly, being pressured into hiring the colleagues or friends of your investors puts the ease of creating a relationship ahead of the hard work of finding the best match for your project. But it can take months to find and evaluate outsourced teams. That’s why many companies avoid outsourcing to begin with. Heere some of the dangers encountered in selecting an outsourced team when you do-it-yourself.
- You don’t diligently check multiple references before hiring. When a recommendation is made by someone you know and respect, additional reference checks seem superfluous or even insulting.
- You scrutinize only the firm, not the individual developers assigned to your project. Your outsourced development work will be done by a team of developers. The makeup of the team and the strength of each individual will affect the quality and time-to-market of your software.
- You hire a team that is not dedicated to your project. You’re supplementing your workforce with an outsourced team to speed up the development process, not slow it down or confuse it. An outsourced team that’s overextended with other contracts, or that’s developing its own products, will not be able to deliver.
- You don’t use a pilot project. Experienced business people know that, when embarking on any new business process, it’s prudent to start with a small independent pilot to decrease the overall risk and the impact on your ultimate project.
Danger #3: You Are Promiscuous with Your Intellectual Property
The dangers of not emphasizing and protecting your unique intellectual property are multiplied when you’re working with outsourced vendors. Here are some specific mistakes that put your IP in danger.
- You put off developing and communicating IP protection policies and procedures with your in-house team. It’s one of those pesky procedural things that are often overlooked in the race to bring software to market. Setting up an outsourced project often highlights the lack of internal procedures for protecting your IP. Do your employees know what a trade secret is? Do they understand the value of your patent-pending software acode and business processes?
- You are careless with employee non disclosure agreements (NDA). Among all the other priorities in the rush of software development, NDAs are often forgotten or may even be considered an insult by core team members. Having employees sign an NDA not only provides legal protection for the idea, it reminds them that the secret information of your company, belongs to your company.
- You have an outsourcing vendor that uses computers with removable media that could be used to create unauthorized copies of your software and IP.
- You use an outsourcing vendor that transmits your source code in clear text over the Internet.
- You have no written agreement with your outsourcing vendor. No non disclosure agreements. No copyright assignments. No document that clearly states who does what and when payments should be made. This puts your IP at severe risk.
- You have an agreement, but you don’t know if your vendor has the proper agreements with its employees. An employee who created your source could potentially leave and legally take your source code as his or her creation.
- You have critical IP in your source code, but you don’t divide or architect your software to isolate the most sensitive IP.
- You use open-source software in your software without understanding license restrictions both for use and geography. This may cause future legal problems with the ownership and sublicensing of your code and may impede your ability to reach global markets.
- You assume your IP is safe because your outsourcing vendor is in a particular country. Assuming that a vendor is honest, without proper reference checks, can lead to disaster.
Danger #4: You Don’t Know What Your Software Should Do
You lack specifications for the software, making it impossible to predict when it’ll be completed. Programmers hate to write specifications. Yet having good requirements and specifications are key to successful software development, whether you outsource or not. And don’t forget about your hardware and performance requirements. Don’t get caught by the old “Didn’t I tell you it has to run on a Mac?” problem.
- You code a detailed prototype instead of writing a specification. This rarely results in robust software that involves your users’ problems, because you get caught up in the minutia of making the software work. You lose the bigger picture, in which you understand what your software should do to solve the problems of your users.
- You believe software cannot be specified ahead of time, because writing software is a creative and innovative process. Then you hire an outsourced team anyway and hope for the best.
- You believe every detail of your software must be specified before outsourcing can be used. You think you must hand off a completely defined and encapsulated project to the outsourced team. While this removes the risk of implementation delays, it delays the start of coding. It also does nothing to accommodate changes.
- You believe outsourced engineers are drones who cannot make any creative contributions to your software development. You ignore the valuable design and development advice available from experienced outsourced software development teams.
- You don’t think through what should be developed in-house and what should be outsourced. Your software should be architected for outsourcing, so that core development can be completed internally and the rest can be safely outsourced.
- You don’t specify performance requirements or provide software use information. Do you know how many users your software needs to support? Or how long users should have to wait to complete important operations? If so, there isn’t enough information to support outsourcing.
- You don’t specify all the hardware and systems that must be supported. Expecting the outsourcing firm to guess what you’re thinking sets the project up to fail.
Danger #5: You Use Meager Engineering Management
Unfortunately, you cannot completely rely on an offshore team to manage your software development. You can outsource the development, but not the responsibility. After all, it’s your software. They will do their best to meet commitments to schedules and to provide a high level of quality. But in the end, it will be your users trying to use the software. Here are how some companies go astray with outsourcing management.
- You hire a programmer to manage software development. This is a disservice to the programmer and to the team being managed. Management and programming are entirely different disciplines, requiring different training and expertise. Being good at one has no relationship to being good at another. The net results is an unhappy programmer and a frustrated outsourced development team.
- You leverage a scientist or CTO to manage software development outsourcing. This is worse than hiring a programmer may actually contribute to the release of the software. Scientists and CTOs often have a “timeless” quality about them, which can lead to delays or even to a lack of schedules to begin with.
- You use an incompetent manager to manage development, which delays the project and frustrates the team. It’s critical that the project manager be able to make and keep commitments and ensure that others keep theirs.
- You assign a person with limited technical knowledge to manage software development. This leads to serious misunderstandings. The manager may be easily fooled by engineers, if he or she is unqualified to evaluate technical issues that arise.
- You don’t give engineering management the appropriate authority to manage and approve work done by the outsourced vendor. This will lead to delays in completing the project.
Danger #6: You Use A Mediocre Software Development Methodology
How do you go about the process of developing software? Do you create an excruciatingly detailed spec and then micromanager? Do you pile up the features for a single stupendous major release? And do you insist that the offshore team cram all those features into the software by next Tuesday? If so, you have a mediocre software development methodology. Here are the dangerous details.
- You outsource without a schedule of software release milestones, leading to confusion and delays.
- You dictate a schedule of software release milestones, to your outsourced team. Even if they cannot meet the schedule, they’ll probably say yes anyway. If the outsourced team’s commitment seems too good to be true, it probably is. It’s just a commitment to say what you want to hear.
- You have just one major software release, containing all the features. This creates a huge risk that keeps you holding your breath until the final release. It also keeps you from making the inevitable improvements and changes to requirements that come up during your software development.
- You can communicate only infrequently with the outsourced team, because you assume things are going okay. As with your in-house team, if you don’t ask, they’re likely not to tell.
- You make a strong (and artificial) distinction between the people who specify the software and those who develop it. This leads to a lack of teamwork and a breakdown in communication.
- You rely on the heroic efforts of individuals to release your software on time. This could create a disaster if a critical hero is unavailable or unwilling to deliver the extra effort required.
- You don’t require unit testing of software modules by your outsourced team, and delays in your software release occur because changes to imperfect modules affect subsequent modules.
- You don’t have a source code control system, and you have more than one programmer, leading to confusion, errors, and delays.
- You don’t use coding standards or require engineers to document their source code. This creates issues for both in-house and outsourced developers.
Danger #7: Your Quality Assurance Is an Afterthought
QA is a critical part of the software development process. It’s also a major concern when you outsource to programmers that are far away. Here are some dangerous mistakes companies make when they outsource that lead to poor quality.
- You use no bug tracking system to keep track of defects, issues, and enhancement requests. You’re constantly tripping over bugs, and known bugs are reported repeatedly. A lack of process for fixing the bugs affects your overall software quality.
- You don’t specify the release criteria for your software and create unclear expectations for the final release. The lack of these criteria may lead to misunderstandings of contract requirements and ultimately unsatisfactory release of your software.
- You wait to start testing until just before you release your software and rush an unacceptable product out the door. You let your customers or users find the bugs. These user experiences create negative word of mouth and press coverage that can doom a project, product, and company.
- You think QA is what happens when users get your beta release. This doesn’t create goodwill. User expectations for quality “out of the box” are increasing over time. Your reputation is damaged by bad betas.
- You think unit testing by your outsourced team is sufficient. No integration testing lets bugs and unusable software get shipped, causing bad user experiences.
- You wait until automated testing can be implemented to test your software. Then you find a huge number of bugs, causing extensive rework and delays in the release of your software.
- You don’t invest in enough computers to create a sufficient test and QA environment, which has a negative impact on overall quality and the performance of your software.
- You don’t test to verify load and performance requirements, and as a result your software does not meet the performance and capacity specifications required to honor user expectations. Customers may like your features and functions, but they may find that your software does not work in “real world” situations.
Before you outsource your software development, it’s critical to be aware of these potential dangers. With better planning, better partner selection, and better ongoing management, you can mitigate risk and outsource with confidence. Talk to an Accelerance Advisor today.