Using an Agency to Augment Your Software Engineering Team and Scale Your Organization Efficiently

In this blog post, we discuss how outsourcing your software engineering enables your organization to stay leaner, longer. We also share best practices to facilitate a successful partnership.

With thousands of open software engineering roles across the country, it can take companies three to six months to recruit and hire software developers. Given the current economic uncertainty, it could be a risky investment to add more full-time employees with all of the benefits, perks, and severance requirements, as we have seen with the recent layoffs across large technology companies.  

Outsourcing enables companies to increase the velocity of software product development to keep their customers and investors happy. Companies are typically hiring external software development agencies for the following reasons:

• Mitigate business risk: Ramp up and ramp down resources to match software development demand with your company’s business performance and goals.                 
• Gain access to new capabilities and technologies: Software agencies have worked with dozens of companies across multiple industries, so your company can get lots of value in leveraging that expertise to help solve your technology challenges. In addition, your company can add new technologies to your stack, e.g. mobile, before hiring an internal team.        
• Work with a team of experts: Outsourcing comes with well-defined software development workflows and processes that bring increased efficiency to your technical operations while decreasing execution risk.

While it is, of course, important that the software development agency has the technical talent and client services to successfully meet your needs, there are some specific capabilities you should look for as the code will ultimately be handed off to your internal teams for further development.     

BEST PRACTICES

Software is a product that is continuously iterated on and improved over months and years.  A robust codebase is one that can be easily understood by developers that have recently joined the team so that they can quickly make an impact on the business.  Some of the process-oriented best practices that are critical for software development firms to hand off code to internal teams for further development are the following: 

• Documentation: Documentation has widely different definitions across different software development organizations.  All code delivered to you should include:  
  • Overview of the product
  • Steps to run software locally 
  • API documentation
  • Configuration items, e.g. where to obtain API keys
  • Description of third-party integrations

Documentation ensures that once a member of your internal software engineering team is asked to build upon the pre-existing code, they can quickly ramp up on the prior work and start adding features as soon as possible. A key aspect of documentation is where it resides. The codebase documentation should reside in a central location that is easy to find, share and search, such as the main readme section of the code repository.

• User Story Development:  Many companies develop User Stories, descriptions of software features that define the user, how the code change will impact the user, and why. By carefully defining user stories into small enough features, software development agencies can make hand-off to an internal development team easier by linking user stories to the code that achieves the feature described in the story.
• Test-Driven Development (TDD): In test-driven development, each new feature begins with writing a test (in code) to assert the behavior of the feature. Beginning with a test, rather than the implementation, focuses the developer on the requirements. Then the test is run to confirm that it fails, which is expected since no feature code has been written. Next, the code is written and all tests are run to confirm that the new code meets the test requirements, while not breaking or degrading any existing features. If all tests do not pass, the feature code must be adjusted until they do before merging features into production. While many development agencies do not practice TDD, The Gnar always tests because the tests written for the new feature also help ensure future features do not cause any regressions to this new feature, ensuring a seamless handoff to our clients.   
• Pull Request (PR) Reviews: Pull requests let developers tell others about changes they have pushed to a source code control system, e.g. GitHub. Once a pull request is sent, interested parties can review the set of changes, discuss potential modifications, and even push follow-up work if necessary. Many companies believe that PR reviews are a time-consuming luxury that can be skipped, The Gnar team does not believe this. The dialogue and engagement of the team around pull requests is invaluable to keeping the internal and external teams on the same page as well as proactively identifying potential issues, which is why all code developed by The Gnar goes through PR review by another team member.
• Continuous Deployment: When building web applications and APIs a common strategy for seamlessly releasing new features is Continuous Deployment. Once a feature is successfully developed, the tests have passed, and PR reviews are conducted, the feature is merged into the production branch of the codebase. By leveraging Continuous Deployment services, code merged into the production branch is automatically deployed to production (website, product, etc). This strategy helps engineers focus their efforts on shipping features.

TOOLS

Software developers love to talk about tools. While the agency should be tool agnostic, the more important area to inquire about is the agency’s development processes. The agency should be comfortable adapting to the tools used, given the tools support the processes that’ll be used for the project.   

A project management tool is needed to execute the software development processes highlighted above, preferably one that enables scrum. Scrum is a method for managing the creation of software features with an emphasis on agile, continuous delivery. There are numerous software development tracking tools on the market, including GitHub Issue Tracker or Jira. Visual tools ensure that there is a consistent set of project priorities across both the internal and external development teams so that the most important user stories are being built.  In addition, these tools make it clear what everyone is working on at any given time. 

While the agency should be happy to use whatever tools the client is using, we recommend the following: 

• Source Code Control: GitHub
• Project Management: Jira
• Continuous Integration/Deployment: Github Actions 
• Cloud Platform: Heroku, Vercel

SUMMARY

Hiring a software development agency is a great way to fill the gaps in your engineering team as well as mitigate risk given the economic uncertainty in the marketplace.  It is important that you make sure to make the right agency choice by ensuring that the software development processes the agency uses enable a seamless hand-off to your internal team to accelerate your product development.

Pete Whiting is the Head of Growth and Client Service at The Gnar Company.   The Gnar Company is an agency that designs and builds foundational web and mobile applications. We help companies, from startup to enterprise, accelerate their development by building software like their in-house teams.