7 Lessons on Building Product with Outsourced Developers
If you’ve ever heard stories about people who tried to develop products with outsourced developers (or if you’ve tried it yourself), you probably know how cumbersome and frustrating it can be.
The sad reality is that the bad reputation of outsourced development is not entirely unfair, but a lot of the responsibility for that also falls on the product managers outsourcing the development. It may be that you’re getting what you pay for, but it’s equally likely that you’re going into an outsourced development project with dramatically misaligned expectations.
Developing software products overseas or with external teams is probably one of the least profitable ways of developing software, largely because so much of the code written this way needs to be rewritten in later stages. However, it’s also true that, under the right circumstances of management, communication and strategy, outsourced development can be highly profitable – the key, as with everything, is in understanding exactly where the problems are.
In terms of the total cost of employment, outsourced development is significantly cheaper that developing local / in-house, so there’s a great value opportunity available. However, that’s only true when there’s clarity about how the outsourced development would fit into the strategy of validating a product and, more importantly, when there’s a clear long term strategy (be that a well-designed roadmap or business plan) that accounts for the costs of an evolving product (e.g: Code refactoring, transition steadiness, etc.)
So, in more concrete terms, you might decide to spend half of what an in-house developer would cost you in order to put a concept prototype into the market. There might need to do a lot of code refactoring at a later date, and there might e some slow-down when you transfer this project to an in-house team, but you’ll have validated your market cheaply. Alternatively, you might just throw away the prototype code once it’s done it’s validation job, and build something more maintainable in-house from scratch!
I recently lead a product that was being developed overseas and we successfully launched three versions of this product in record time, learning a lot about working practices along the way!
Understanding outsource teams
On the one hand, many of the challenges of working with an external team are not so dissimilar from working with (or building) an internal team. The main differences hinge on communication, domain knowledge, and how invested you and your external team are in each other.
When working with in-house developers, you might try and separate out the processes of hiring, “localising” and getting value from the team. On the other hand, when working with an external team, you’re essentially compressing all of those phases into either a single project or, at best, a high condense time-frame.
With that said, here are seven lessons on how to leverage an outsourced development team, and get the biggest possible return from their work:
1) Hire a Development Firm or Individual Developer based on a references, not a Google Search
Finding good external developers (be they overseas or even just in a different city) is a huge challenge. The best way to go about this is by looking for references in your network. Whenever you find someone who is willing to recommend a developer, ask for information about their strengths and their weaknesses. It maybe that someone writes epic code, but isn’t a great communicator – that may work for you, but only if you’re aware of that skills balance. An honest, balanced appraisal is essential.
2) Test your developer for a few weeks
There’s a reasonable chance of under-performance when you hire an outsourced developer. This might be for reasons of culture, skill, or even a lack of domain knowledge hindering their ability to understand what it is you’re asking for. Try to give them a small warm-up project that would supplement later development.
This is important because the earlier you detect a bad fit, the better. If there’s no good fit, terminate and move on to another developer.
3) Learn to focus only on what’s critical
You need to understand that when developing externally, you will usually receive less than what you expect. This is something that sadly seems to come natural to this model, perhaps because many of these firms don’t have the level of investment you might have in pixel-perfect UI fixes and polish.
Adjust your expectations so they match what you’re actually investing in development, and focus your energy in the most critical components and functionalities.
4) Don’t introduce your bureaucracy into their development flow
External developers usually don’t care about your Pivotal Tracker / JIRA / Trello + Slack setup. Don’t ask them to learn how to use your stack of management tools, because they either won’t, or they won’t do it well. After all, that’s not what you’re paying them for.
Instead, ask them about what method of communication and tracking they prefer and embrace that tool or system, whatever it is. You will find that it’s easier for you to learn this, and not the other way around.
5) Get used to the QA role
When working with outsourced development firms, there’s always the promise of High Standard Quality Assurance. Sadly that promise usually goes unfulfilled to some degree or other. The only way to assure quality is to perform your own testing.
When receiving builds or new releases, focus on the critical components of the software. Don’t assume that certain functionality is working just because it was working in the last release. Things get broken. Test everything!
6) Be technical, or at least find someone technical to help you
Just because you’re developing your software externally doesn’t mean that you get away with not having technical chops. In fact, when developing externally you need more technical skills than ever. The main reason for this is not the classic cynical reason of being played for a fool with technical jargon so the developers can justify their delays.
In reality the reason is simpler – outsourced developers don’t understand your business logic as well as you, and therefore they need granular and highly technical documentation so they can implement what you’re asking for.
I need the software to make a payment when X happens
…doesn’t necessarily get you anywhere.
I need you to write a script that makes a request to this API, and then I need you to store the response in this database field
is more likely to get you exactly what you want.
7) Track the project!
This is probably the most important lesson we learned. Tracking your project boosts the chances of success and helps you to speed up the development process. The whole purpose of tracking is to have a clear picture of the product state and viable next steps. This is obviously necessary with any team configuration, but it becomes utterly essential when you’re working with a team outside the company.
One of the best ways I have found to track an outsourced project is by using an agile-inspired chart I designed for some of my own outsourced projects. The chart has 4 main columns:
- Issues: Here is where your backlog starts. All the bugs, tasks or fixes that you have determined or found on a build review go here. Usually this column gets filled with new issues after receiving new builds and/or releases from your developers.
- Committed: In this column you put everything that has already been submitted to the developers for fixing, be it via email or their own project management tool. Usually what I would do is write an afternoon email that they would see in their morning with all the issues that I found and that I’m adding for the next day.
- Rejected & Done: When the developers send a release or build, they always send it with a set of release notes that describe what was fixed and/or added. Based on this, a review of what was sent is made, and all the issues that were tackled in the release are moved from Committed to either Rejected or Done.
When something is rejected, this means that the issue needs to be recycled back into Committed again until it is fixed.
By following this simple tracking method, you can have a clear idea of the state and progress of your project, no matter where your dev team are based.
Developing a software product with an external team, especially an overseas team, can be very challenging. That said, sometimes there are budget constraints and involvement limitations that make it impossible to develop those products in-house, and so you don’t have much choice.
Equally, outsourced development can help to achieve specific goals that can later represent significant return on investment. The most relevant example would be developing the MVP of an untested idea.
For those cases, having a clear idea of how to proceed, and how to enable and give structure to the team can determine the difference between success and failure. Having a clear framework and a set of guiding principles like the ones above can at least boost the chances of success, and mitigate the downsides that come from developing a product with an outsource development team. Make sure you have something similar in place before you spin up an outsourced project, and if you’ve got any other tips for making sure these kinds of projects are a success, I’d love to hear about them in the comments!