We outsourced before and were not satisfied with the service.”
“Our managers need to be on hand to manage.”
“We don’t think it’ll produce the results we need.”
These are just some of the
many objections companies have to outsourcing.
Though these are legitimate concerns, companies often have bad experiences with outsourcing because they aren’t doing it right.
outsourcing work, you must shift your thinking and practices to accommodate it. But, as you’ll see in this article, it’s not as difficult as you think.
Here’s how to do it.
Set clear project goals
Clear project goals are the heart of a successful
nearshore outsourcing relationship.
Your team—or any employee for that matter—needs to have a clear destination in mind before they can set out to do anything meaningful.
That means laying out the project’s scope, timeline, and deliverables clearly from the start.
Doing this is especially crucial for an
outsourced team since they will work remotely and more independently.
Hence, you want to give them what they need to always move in the right direction.
But it would be best if you went beyond what your team needs to do and discussed
why they need to do it. Maybe you can share your dream or grand vision of your app.
This is a great way to inspire your team to do their best work. The celebrated author
Simon Sinek puts it best when he says:
If we want to feel an undying passion for our work, if we want to feel we are contributing to something bigger than ourselves, we all need to know our WHY.
So, besides sharing the WHY, how can you ensure you set clear goals for your outsourced team?
First, you need to know the distinction between
goals and objectives—because you’ll need to communicate both.
In other words, you need to break down your goals into objectives because these will form the daily tasks and milestones your outsourced team must accomplish.
For example, let’s say one of your app goals is to maintain a retention rate of 5%.
One of your objectives to support that goal might be implementing a push notification feature with a 50% opt-in rate.
It’s important to use
SMART goals here, as this approach ensures that your goals are met within a specific timeframe. Plus, it gives your team a metric to aim for.
For instance, saying you want to monetize your app is vague and will probably lead to varying results.
Restating your goal to
I want to monetize the app to earn $1,000 per week by the end of the year is much clearer.
And to ensure you cover all the important goals and objectives for your app, it also helps to use a
software requirement specification.
A software requirement specification is a document that states the objective of your app in three key areas.
The first of these is
business requirements. They cover the goals that benefit the business and stakeholders.
Examples include increasing revenue, grabbing more market share, or lowering costs.
User requirements or objectives that benefit users when they use the app represent the second key area.
For instance, the goal of an Uber user is to get a ride conveniently in minutes wherever they are.
The third area is
system requirements, which detail the system’s behavior. These are granular goals that get into the app’s technical workings.
An example of a system requirement is
the app must load in three seconds or less.
Once you have all your goals laid out, the last step is to create a
statement of work (SOW). This legal document lists the deliverables the team needs to accomplish to finish the project.
It includes schedules, key success metrics, testing standards, and payment details.
A statement of work document is important not just for clarity on the part of the team but also for your protection.
It puts all the project details in black and white, so it can resolve any legal disputes that might arise.
Defining and communicating your goals might seem like hard work—and it is!
But it’s the foundation for a smooth and successful relationship with your nearshore team, so it’s worth doing right.
Ensure the availability of information
A key challenge when working with remote teams is seamless and
immediate access to key information.
This includes key project details (such as bug fixes or changes in requirements), project files, and data.
This is especially crucial when you have an in-house and
outsourced team working on the same project.
One common complication can arise if the in-house team gets updated with project changes and the outsourced team doesn’t.
In that case, the latter will end up working on the wrong thing or duplicating deliverables already done by the in-house team—a total waste of time!
To solve this dilemma, you need a capable project manager.
A project manager is the point person who updates everyone with relevant information about the project.
He or she is the glue that holds the entire project, ensuring that all tasks are correct and on schedule.
An outsourced team will likely have a project manager of their own. However, you shouldn’t rely solely on that person.
You should also have a similar role in your company, someone who will coordinate with his or her counterpart.
Nevertheless, a project manager can only do so much. You also need to make file and information sharing easier for the remote team.
One helpful approach is to have a knowledge base.
A knowledge base is an online repository containing every project resource. It often includes deliverables, product roadmaps, coding standards, task lists, recent updates, and other files.
The goal of a knowledge base is to make all relevant project assets instantly available to all team members, whether in-house or outsourced.
If any piece of information is updated in the knowledge base, it’s rippled out to everyone, ensuring the entire team gets the latest version.
Nowadays, building a knowledge base with tools like
Notion and Slite is easy, so there’s no excuse for not having one in your project.
To complement your knowledge base, it’s critical to also have an online server for storing project assets such as codes, images, videos, and prototypes.
A quick solution is to use cloud storage solutions such as Google Drive or Dropbox.
Ideally, you should also have a Git repository (like
GitHub) that helps track the versions of your software files.
That way, you’re guaranteed that your team is always working on the correct version.
Now, while giving your development team immediate access is crucial, you should also temper it with security.
That’s because giving an outsider free rein over your data is asking for trouble. All it takes is an errant developer to breach and steal your data.
Here’s a statistic from the
Ponemon Institute Cost of Insider Threats report to keep you on your toes:
One way to minimize this threat is to have an
Identity Governance and Administration (IGA) system in place.
This security protocol helps you manage your network’s roles, limiting users only to the data and applications they’re authorized to access.
That way, when a breach occurs, attackers can’t penetrate through other areas of your network.
The bottom line is that free and
secure access to information is a must for onshore teams.
Maintain clear communication channels
So far, we’ve identified having clear goals and instant access to information as crucial ingredients in a successful onshore project.
But all of that is impossible without the proper communication channels.
Statistics are saying that it’s easier said than done. According to Minim, communication is the biggest struggle most remote IT teams have.
And winging it won’t be enough. With an outsourced team, you need to define how and when you should communicate.
Ideally, you should cover the two types of communication:
synchronous and asynchronous.
Synchronous (or real-time) communication is ideal for anything that requires deep interaction and rapid exchange of ideas, such as brainstorming.
It’s also great if you need to communicate urgent matters, like mission-critical bug fixes.
Asynchronous communication is best for other everyday tasks like sending notes, sharing files, or providing non-urgent feedback.
That’s because this type of communication is non-disruptive, meaning people can get to them at their convenience.
Here are the recommended synchronous and asynchronous communication tools you can consider using.
More than using the right tools, though, the crucial thing is how your team uses them. You need to establish rules that benefit everyone, and enforce them.
For instance, you might establish the proper times to use email vs. instant messaging.
Setting rules reduces communication mishaps like unread messages, lost files, or outright confusion.
However, it would help if you also were wary of too much communication.
That’s because over-communication is also the number one distraction in workplaces—and yes, this includes remote work.
A rule of thumb is that you should communicate often enough to keep everyone updated on the project’s progress. But you shouldn’t overdo it to the point of interrupting a person’s work.
In remote communication,
quality is more important than frequency. Every message you send should be concise and considerate.
Include all relevant information so the person on the receiving end doesn’t need to ask follow-up questions. Also, don’t overwhelm them with too much, either.
Allow sufficient autonomy
The big advantage of a nearshore team is their independence. So, the worst thing you can do is micromanage them.
If you’ve followed this article thus far, your team should have everything they need to implement your project successfully. All that’s missing is trust.
Micromanaging is a dangerous type of behavior not just for the development team but for you as well.
It can lower morale, demotivate your team, and even slow down app development because everyone is dependent on you.
More importantly, micromanagement is a huge time sink. Just consider that you outsourced your development work so that you’ll have more time to work on other things.
You should take advantage of that.
Admittedly, it can be difficult to trust a third-party developer with your app vision. That’s why micromanagement is a hard habit to break.
The best way to control that is to have a regular reporting system. This guarantees you’ll get consistent updates from the team without micromanaging them.
Before you begin the project, you should be upfront with the development team about how often you want to receive updates.
At DECODE, for example, we check in with the client on a daily basis to keep them in the loop.
Make sure that your team’s software methodology also supports the amount of involvement you want.
For instance, the DECODE team adopts the Agile Methodology.
In Agile, development is split into sprints. Each sprint is like a mini-development, containing designing, building, and testing rounds.
At the end of each sprint, which lasts around two weeks, we conduct a review session with the client so they can see the work in progress.
They could give feedback and suggestions, which will be incorporated into the next sprint.
This process ensures that the client has control over the app’s direction without having to be too involved. We can tell you that this approach works wonders, and clients love it.
Micromanagement isn’t the answer to a successful nearshore app project.
Trust, proper systems, and clear communication are.
How to pick your ideal nearshore team
As you can see, working with a nearshore development team is not that difficult.
All it takes is clear goals, instant access to information, clear communication, lots of trust, and outsourcing to the right team.
The last one is arguably the most vital, so you must do your homework when scouting for potential agencies.
To help you out, we’ve prepared the
12 questions you need to ask before hiring an outsourced agency. Hopefully, it will give you insights that can lead to a smart decision.