Preventing Outsourcing Disasters

Five tips for ensuring success

A lot of outsourced projects become disasters — people disappear, the product turns out to be completely different from what you imagined, development takes double the time originally estimated.

Picking a good development partner is obviously important, but managing the development well is equally important. Here’s five tips that can save you a lot of headache:

Write thorough documentation

First and foremost, be very clear about what you want built. Write down the vision — who is the target user, how will they use this app, what will they get out of it, etc. Document as much as possible.

If you’re not a product person, it helps to engage a good product person to think through the vision and lay out a roadmap. They can help you think hard about your vision and force you to build as little as possible to launch and test your hypothesis.

Especially with mobile apps, it’s natural to want to build a “lot of experience” before launch, but more often than not that’s a bad idea. If your MVP will take months to build, it’s not an MVP. Try to bring it down to one, simple, beautiful use case that can delight the user.

Make a clear roadmap with what you’d like in version 1, 2, 3, etc. Even though you may not have much clarity beyond version 1, it helps for the team to know what you have in mind, and design things accordingly. Giving them a roadmap in advance helps many unnecessary redesigns and code refactoring. Plus, writing it down helps you think through your vision better.

Finally, take the time to mockup clear wireframes, using a tool of your choice or just pen and paper. For each screen or page, mention what’s the most important thing you want the user to see and interact with. This orients the design team in the right direction and saves you a ton of back and forth time.

Have a clear, simple vision and document it thoroughly

Setup for speed and agility

Whether you’re going for a freelancer or an agency, think long term partnership not one off transaction — go for an “extended team” model than a black box agency model. The biggest mistake people make is hiring someone to build the app and be done with it. Launching an app is the beginning, not the end. You’ll need the team way beyond that.

If you’re going for an agency, make sure you can interact with the designers and developers directly. They’ll usually assign a project manager to you, but it helps a lot if you have direct access to the people that work on your product.

Look for technical project managers — ideally they should be Architect level people that can take your inputs and guide the team, not just people managers who simply forward emails. If it’s remote agency (India, China, etc.) look for project managers with US experience, and insist on seeing resumes and code samples of every engineer that works on your project.

Also for remote teams it helps if the designers and developers are in the same location, ideally the same building. You’ll have to work harder if they’re in different countries and times zones.

Insist on using agile communication tools like slack so they are always available to chat. In the first call, clearly explain the roadmap, milestones, schedule, and insist on weekly sprints and demos. You don’t want them to spend months “polishing” it before showing it to you. You want to see a build every week, even if it’s very raw.

Finally, setup tools for project management and collaboration— for example, slack for communication, asana for task management, invision for prototypes and design reviews, github for code, etc. Make sure no communication is lost and everything is tracked.

Setup a basic cadence in place before any work begins

Checkin regularly

Keep in touch with the team very frequently — schedule a 15 minute stand up call three days a week, just to checkin and see how things are going. Even if there’s nothing to discuss, it helps to see what’s going on and resolve issues quickly. Plus, it’s a good relationship building exercise — you get to know them and vice versa.

Be very disciplined about code checkins. Setup a code repository on github, for example, and insist that they checkin there regularly. Keep an eye on the checkins. Some firms don’t do this until you fully pay them — in my mind that’s a red flag.

You should be watching the code early on, and even if you don’t understand code, you can observe their quality by the frequency of commits and quality of code comments.

Use weekly sprints and checkin frequently.

Test thoroughly

Create a “build acceptance test” with basic test cases that should pass for every build, and have them execute it for every build. This should test all the basic functionality of the app, and will catch any new defects introduced in newer builds.

Make sure every build is tested thoroughly. Testing is often overlooked and underestimated with mobile apps. Your testing should include three areas:

  • Functionality: Does the app work as expected?
  • Stability: Does it work without any crashes? Can it handle situations like lost network connection or poor bandwidth? Does it drain the battery?
  • Performance: Is it fast enough? Does it feel sluggish?
Test every build thoroughly and give feedback early and often.

Be responsive

Last but not least, respond to the team as quickly as you can. Don’t be the reason for stalled development. Note that these people are working on multiple projects, not just yours. So they keep switching between projects.

If they have a question and you respond quickly, they’ll continue to work on your project. If you don’t, they switch to another project and that’s time lost on yours. So it’s good to respond as fast as you can.

Be responsive and unblock issues as fast as possible.

Happy to help you think through your vision and pick a right team that works for you, even if it’s not us! Feel free to email me.

Like it? Please recommend it so more people can read it…. thanks!