How to Scale Engineering Teams from Startup to Corporate
How does an engineering team transition from a scrappy, startup mindset to think in terms of scale? It takes intentionality and strategy. As Coupa has transformed from a small organization to a leader in Business Spend Management, we have grown from a team of two engineers in 2006 to over 900 in the engineering team in 2022. Over the years, our teams have faced growing pains — as Coupa acquired companies, more people and more technologies had to mesh seamlessly together. Below are some of the best practices we have adopted to improve internal communication, improve code quality, and allow our engineers to quickly and efficiently add features.
When a software product is in an early stage and teams are small, design decisions can be made over a quick meeting, code reviews can be done by sitting next to each other, functional testing can be done manually, and deployments can be done at will. As teams grow in size and geographic location and the product matures and expands, communication and strategy on scaling the business becomes of utmost importance to avoid spaghetti code, performance lags, and siloed engineering teams with little integration.
9 ways engineering managers can scale their engineering teams
You may be asking yourself how to manage hundreds of developers, working across dozens of functional teams, across several time zones. It’s important to know where checks and balances should be implemented to ensure quality, efficiency, and knowledge transfers without hampering the speed and efficiency at which a startup operates.
1. Design reviews
At Coupa, all changes regardless of size go through a formal review process, focusing on the functional, technical, performance, and security aspects. Analyzing the impact of the change across the entire suite of software products is very important to prevent unwanted outcomes or confusion for our customers or other engineers trying to add a feature that touches unknown parts of the code or application. Subject matter experts review the changes internally first, and when needed these are lined up for a formal review by our principal architects.
2. Code reviews
To ensure that code being committed doesn’t negatively affect the system, all Github commits are required to have a pull request identifying what has changed and why. Depending on what kind of changes are made, the tool identifies various categories of reviewers to be assigned like API, UI, security, or migration. Reviewers don’t generally stop at finding problems, but they also support developers in making required changes. Reviewers are picked after a thorough evaluation process to ensure there are no loose ends.
3. Data table schemas and data migrations
As customer datasets grow, solutions must be built to allow for zero downtime schema changes. For example, engineers at Coupa built an internal tool which alters a table’s structure without blocking reads or writes to it. When data migration on these large sets of rows is required, Coupa uses a robust framework to divide and conquer the problem by distributing smaller chunks of work to multiple processes.
Keeping the performance implications of proposed changes in mind throughout the entire design and implementation phase of features will save many headaches near the end of a development phase. Coupa engineers have built a framework for testing pull requests on sanitized production data to get early feedback on performance implications. “Labs'’ simulate production scale load and test features to measure if the performance is affected by increased loads. Automations have been built to check the codebase of any increase in memory usage or app-bootup time at the end of every two-week sprint.
Paired with performance, customers need to expect and trust the software’s reliability throughout each release. Teams at Coupa have KPIs like search response times, page load times, and error rates on calls to third party software that are reviewed regularly so that proper and timely corrections can be made. More importantly, teams should build safeguards around what customers can do with your application. Without these, customers may end up unknowingly exploiting our systems.
6. Code styling
Start-ups sometimes may be more focused releasing and short-term wins rather than long-term maintenance and code quality. To enforce the coding guidelines and standards outlined in the community as well as the company, Coupa engineers use static code analyzers like Rubocop or ESLint as well as code formatters. Reference this article on how to set up these tools.
7. Automation testing
Every pull request should pass the suite of existing tests to ensure the new functionality works as well as all previous functionality that is still intact. Not every part of the application can be tested via unit tests, so Coupa supplements the thousands of unit tests with additional test suites for UI / API / migration / end-to-end tests. Developers and reviewers must ensure appropriate coverage is added within the test suite for the new functionality being added.
8. Application security
Hands-on labs and annual mandatory compliance training should be put in place to make sure all developers know and understand the OWASP Top 10 Security Vulnerabilities that safeguard the application and customers’ data. Delivering a secure and scalable platform is a top priority and Coupa engineering goes above and beyond to ensure compliance so the entire Coupa community feels secure.
9. Release cycles
It’s very important to give customers adequate time to test and plan for upgrades. Coupa Engineering and Documentation teams work together to ensure that all code changes for major releases as well as continuous integration updates for customers are documented well and customers have been properly trained on what they can expect. By having this process in place we keep the channels of communication open and avoid unwanted setbacks.
Growing a global engineering team takes a great balance: productivity vs process. The goal is always to move at the rapid pace of a start-up but have smart (but not cumbersome) processes to keep all engineers informed about architecture and design changes as the team grows. And while Coupa is always #StrivingForExcellence and will never stop improving with that balance, hopefully some of these processes will help with your growing team.