PayPilot: a React frontend team inside a client-led payroll rebuild
The team of 5 joined the client's own payroll SaaS rebuild within weeks, grew to 15 and stayed until 2026.
Industry
Fintech, payroll software
Location
Canada
Client since
2022 (to 2026)
Status
Delivered, March 2026
5
at the start
15
at the peak
4 years
February 2022 to March 2026
22 days
to contract
Our client is a company that provides payroll SaaS to small businesses in Canada. According to the NDA, we use a fictitious company name and refer to it as PayPilot throughout this story. The software helps send money directly to employees' bank accounts, view payment details, generate Records of Employment, withhold and remit taxes, and more.
Our client, PayPilot
Since its first seed round in 2014, PayPilot has raised $14.8 million overall. By January 2022 the company was building a new version of its product, designed and led by its own engineering team, and the build required more specialists with project-specific tech skills. Initially, the client needed 5 React engineers and planned to scale the team further. Not many vendors could provide that number of experts immediately.
To fill the talent gap, PayPilot turned to Brocoders. Within a couple of weeks, we provided 5 experts and started developing the first module. Throughout the project, we continued onboarding new people, and our team grew from 5 to 15 software development experts at its peak.
As a result, we created a frontend team inside PayPilot's own engineering organisation, through team augmentation run as a senior engineering pod: our own project manager and QA, working in the client's process. Here is what we did.
PayPilot at a glance
Client
PayPilot (NDA name), payroll SaaS for small businesses, Canada
Product
Pays employees, remits payroll taxes, Records of Employment, year-end forms, QuickBooks and Xero integrations
Engagement
February 2022 to March 2026, delivered
Team
5 at the start, 15 at the peak
Modules
Record of Employment, First-Time User wizard, Year-End Form, Finance and insufficient funds (NSF), Accounting Dashboard, Billing
Stack
React on the frontend. Coda (documentation workspace). The client’s own backend
Challenge: rebuilding PayPilot's backend and frontend from scratch
When the client came to Brocoders, they already had a working solution. To improve the scalability and maintainability of the system, they decided to rebuild the backend and frontend from scratch. While their internal team was working on the backend, Brocoders joined the frontend development. The existing product kept running for its customers under a separate team while the new version was built.
How PayPilot's CTO split the work with an in-house team
The client's CTO managed our team like the client's other engineering units, and allocated it a list of modules to deliver. The client's engineers kept the rest.
The client’s engineers kept
The product and the plan. The backend. Their own in-house frontend team and the UI Lead who reviewed our work. The Billing module, which our engineer handed to them in March 2023. Moving customers to the new version, which the client did itself.
The Brocoders pod owned
The frontend modules assigned to the team, from the client’s requirements to release. The team’s project management and QA. Hiring and replacing engineers to the client’s requirements. Documentation and coding standards for the modules in Coda.
Solution: building the PayPilot frontend team
After joining the project, our task was to create a remote development team as quickly as possible through team augmentation, to help the client deliver the required functionality on time. We immediately provided 5 specialists, including a Project Manager (PM), 3 React developers, and 1 QA specialist. As the workload increased, we started looking for the missing tech talent on the market as well as onboarding the available engineers within Brocoders' team.
How fast the start was, from the record:
Jan. 9, 2022
The client’s CEO found Brocoders in a vendor directory and sent a short request: React developers to speed up a big project
Jan. 11, 2022
First call with Brocoders’ then CEO. Scope: 5 developers, needed immediately
Jan. 13 to 14, 2022
The client’s CTO joined. NDA signed, CVs sent within a day
Jan. 18, 2022
Working-methodology call with the CTO: the client’s accounts, repositories and Slack, with Brocoders running its own team’s process inside them
Jan. 31, 2022
Contract signed. First engineer onboarded straight away, then the full 5
Project onboarding and code review
PayPilot is a complex payroll platform with many industry-specific requirements and integrations with other systems, like QuickBooks and Xero, so we needed time to learn the project specifications in detail. What’s more, a big distributed team, including people from Ukraine, India, and Canada, was involved in the project, so we had to get acquainted with all team members and establish efficient working processes.
To understand the project details and get into the development faster, our PM cooperated with the Product Owner and the UI Lead on the client’s side. Such collaboration ensured a smooth project onboarding.
Once we felt fully integrated into the project, we started auditing the system and conducting a review of the existing code. We identified some performance issues and scalability bottlenecks, made demos of what we’ve discovered to send to the client's team, complete with our suggestions for improvements.
From here, we established a clear communication process and became fully-fledged members of the PayPilot development team.
Streamlined tech team recruitment
After the code review and bug fixing, we started working on the frontend development, and our workload significantly increased. To fill the talent gap and accelerate the delivery, we started adding new developers to the project.
Our Chief Delivery Officer (CDO) selected suitable candidates from the Brocoders’ team and was working on establishing effective communication and collaboration between all the team members, as well as handling critical issues, like replacements of developers or QA specialists.
Apart from picking developers from our team, we also launched a separate hiring campaign. Each candidate passed a thorough selection process conducted by our HR manager, the recruitment team, and the tech lead in charge of the PayPilot project. Here’s what the process looked like.
After receiving the requirements for candidates from the client, our HR specialist started searching for developers. They conducted initial screening interviews to vet potential applicants and arranged interviews with the tech lead (on our or the client’s side) to check their technical skills. Based on each interview, our recruitment team provided feedback to the client. After the developer was hired, the HR specialist took care of the equipment purchase, to ensure the newly added member could start working on the project without any delays. The client’s CTO read the CVs and interviewed the first engineers, and received feedback on every later candidate before an offer.
As a result, we established a streamlined recruitment process that allowed us to find the required experts fast. But how do you ensure the smooth onboarding of new developers so that they could understand the project specifics fast and follow its quality standards?
Enforcing coding standards through centralized documentation
As we’ve already said, PayPilot is a complex product with numerous technical challenges. To onboard new developers to this project and ensure they adhere to the established coding standards, we needed to create thorough project documentation. It serves as a valuable resource that provides a clear understanding of the product’s requirements, functionalities, and standards. In Coda, we have centralized this documentation, making it easily accessible and enabling new developers to quickly grasp the project’s intricacies.
The documentation includes reporting rules to ensure consistency and accuracy in the reporting practices across the development team, promoting seamless collaboration and effective decision-making.
The coding standards documented in Coda outline the best practices and conventions that developers must adhere to when writing code for PayPilot. By maintaining a standardized coding style, the project can achieve better code readability, maintainability, and overall code quality. This uniformity also facilitates collaboration among team members, as everyone can understand and work with each other's code more efficiently.
With unified project documentation and coding standards, PayPilot ensures that new developers joining the team can quickly familiarize themselves with the product, contribute effectively, and maintain a high level of consistency and quality in their work.
The PayPilot team at Brocoders, 2022 to 2026
The team changed size with the client's roadmap.
February 2022
5 people: a project manager, 3 React developers and a QA engineer
September 2022
15 people at the peak, from Brocoders’ own team and from the market
2023
15 people in the first half of the year. Billing handed to the client’s engineers in March
2024
4 people
2025 to March 2026
1 React tech lead, until the engagement closed
Delivering the PayPilot modules
Our team owned the frontend modules assigned to it. A PM from our team set up operational processes, conducted requirements solicitation, and communicated directly with the client’s product managers. Our development was supervised by the UI Lead on the client’s side.
Working on the project, our team developed 6 modules, including:
This feature enables the company admin to create a detailed employee form. Typically, this form is required when an employee requests it or when they plan to transition to a new company. It encompasses essential financial information such as payrolls, fees, and vacation days, providing a comprehensive overview of the employee’s financial profile.
It’s a sophisticated wizard that simplifies the process of entering essential information about the company and employees during the initial use of the app. This component intelligently mirrors the main pages and guides the user through the key sections of settings and app functionality, ensuring a step-by-step completion of all necessary details.
It is a user-friendly feature that allows company admins to create a comprehensive form for their employees at the end of the year, specifically for tax purposes. It provides a convenient and cumulative method for generating and customizing this form to meet the necessary requirements.
It’s a large module that includes various features for managing microtransactions, such as fee payments, handling insufficient funds (NSF), and facilitating tax payments through banks. It primarily caters to risk agents and bookkeepers, providing them with efficient microtransaction management capabilities.
An accounting dashboard and a billing module for the new version. In March 2023 the Brocoders engineer on Billing handed the module to the client’s own engineers.
As a result of our work, PayPilot received a scalable frontend for its new version, with the flexibility to accommodate future growth. External testing of the new version began in autumn 2022, on the client’s schedule. Russia invaded Ukraine in February 2022, 3 weeks after the team started. Part of the Brocoders team is based there, and the main development division is in Estonia. The engineers in Ukraine kept delivering.
That’s what the CEO of PayPilot says about that period:
Within 3 weeks, once they got resettled, they showed up for us! Boy, did they ever! Their team began contributing at a level that belied the tremendous difficulties of their situation ‒ it was pretty incredible to witness! There weren’t willing to let their livelihoods become another casualty of the war.
Fast forward to 6 months later, there is no doubt in our mind that we wouldn’t be where we are at with our project today without Brocoders’ contribution.
CEO and Founder, PayPilot
Result: 4 years inside PayPilot's engineering organisation
We established a team capable of developing features for a complex fintech project fast, which helped PayPilot accelerate the development of its new version and start external testing in autumn 2022, on its own schedule.
“We would not have been able to deliver on our short timelines without them showing up for us in the way that they did.”
CEO and Founder, PayPilot
What the PayPilot team delivered, from the first message to the last module:
A frontend team on the client’s accounts in 3 weeks
First message Jan. 9, 2022, contract Jan. 31, engineers onboarded in February.
5 to 15 engineers in 7 months
The client’s CTO interviewed the first engineers and received feedback on every later candidate.
External testing of the new version from autumn 2022
On the client’s schedule.
6 modules built for the new version
Record of Employment, First-Time User wizard, Year-End Form, Finance and NSF, Accounting Dashboard, Billing.
4 years inside one engineering organisation
February 2022 to March 2026, with the billing module handed to the client’s own engineers in 2023.
The client's repositories and CI pipelines. The backend was the client's
FAQ: adding a React team to a payroll SaaS rebuild
Can a Brocoders pod own one part of the product while our in-house team keeps the rest?
Yes. On PayPilot the client's CTO kept the backend, an in-house frontend team and a UI Lead, and gave the senior engineering pod a list of frontend modules: Record of Employment, First-Time User wizard, Year-End Form, Finance and NSF, Accounting Dashboard and Billing. The pod ran its own project management and QA inside the client's accounts, repositories and Slack from February 2022 to March 2026. In March 2023 our engineer handed the Billing module to the client's own engineers.
How fast can a React team join a rebuild that is already running?
On PayPilot, the client's first message came on Jan. 9, 2022, the contract was signed on Jan. 31, and the first engineer was onboarded straight away, with the full 5 (a project manager, 3 React developers and a QA engineer) working in February 2022. In the words of the client's CEO: "Within a couple of weeks, we had a team and team leader in place and we were off to the races." A senior engineering pod works the same way: the client picks the people, and the pod runs its own process inside the client's tools.
Who owned what on PayPilot?
The client owned the product, the plan, the backend and its own frontend team. Brocoders owned the frontend modules assigned to its team, with its own project manager and QA. The client's UI Lead reviewed the work.
Did Brocoders take over the PayPilot product?
The client designed, led and owned the rebuild from the first day, and moved its customers to the new version itself. Brocoders joined the client’s team for the frontend.
Can we interview the engineers, and what happens if one has to be replaced?
Yes. On PayPilot the client's CTO read the CVs and interviewed the first engineers. Every later candidate passed Brocoders' screening and technical interviews, and the client received feedback before an offer. A replacement goes through the same steps and hands the work over inside the module.
Do you hire from the market for one client's stack?
Yes, to the client's requirements. On PayPilot, Brocoders added React developers from its own team first, then hired from the market to reach 15 people within 7 months.
How does the team scale down when the roadmap changes?
With notice and a handover. PayPilot went from 15 people in 2023 to 4 in 2024. The billing module went to the client's own engineers in March 2023.
What if we are not sure the codebase is ready for an outside team?
Start with a software audit. On PayPilot the team's first weeks were a code review and an audit of the new version's frontend, with demos of findings sent to the client's team.
More senior engineering pods and fintech work like PayPilot
