Make vs. Buy: Valuable Lessons from a Commission Tracker Misstep That Led to Smarter Solutions
Three weeks. That’s how long it took to build a homemade commission tracker in Google Sheets. What began as a simple project—columns for rep names, deal values, and payout percentages—quickly spiraled into a patchwork of exceptions, edge cases, and Excel gymnastics. What followed is a lesson that speaks to a question every business eventually faces: should we build our own tools or invest in something purpose-built?
When Control Becomes a Liability
The initial appeal of building a custom solution is undeniable. It’s flexible. It’s yours. You know exactly what you need—so why not roll up your sleeves and build it?
The early days were promising. Within hours, the first version of the tracker was live. It was clean and simple. Adding a few conditional formulas to calculate commissions felt like a win. The team could tweak it on the fly. They felt in control.
Then came the cascade of change requests:
- Add accelerators for deals above a certain threshold.
- Introduce clawbacks for early churn.
- Layer in SPIFs (Sales Performance Incentive Funds) but only for Q4.
- Enable split commissions between teams working collaboratively.
These weren’t unreasonable asks—they were natural progressions of a growing sales operation. But they meant the spreadsheet, originally a lightweight tool, had to evolve into a living, breathing system. And unlike software products designed for complexity, spreadsheets do not scale gracefully.
Within weeks, the tracker had ballooned into a 17-tab labyrinth held together by 50+ formulas and undocumented logic rules. A red cell that turned crimson when “something didn’t feel right” was, somehow, the team’s version of a QA process. There were no automated audits, no error handling, and certainly no rollback mechanisms.
Then came the breaking point.
The Trust Breaker: When the System Fails the People It’s Meant to Serve
A €5,000 commission payout went missing. A rep flagged the error. A manual check revealed a broken formula, caused by a deleted row no one noticed. It was a simple mistake with a massive impact—because it didn’t just affect numbers. It shattered trust.
Sales commissions are uniquely sensitive. They’re not just line items on a payroll—they’re the manifestation of performance, effort, and expectation. When they’re wrong, even once, the system’s credibility is questioned. And rebuilding that trust can be harder than building the spreadsheet in the first place.
The error wasn’t due to negligence. It was the inevitable result of a tool that had outgrown its purpose. Patchwork fixes turned into brittle dependencies. The team found themselves more focused on maintaining the system than using it.
And that’s when the decision was made: buy.
Buying Isn’t an Admission of Defeat—It’s a Strategic Realignment
There’s a common misconception in business that building is superior because it demonstrates innovation and resourcefulness. But what if the goal isn’t to innovate in software—but to scale a business, deliver value, and avoid rework?
The decision to buy a commission management system wasn’t about chasing bells and whistles. It was about acknowledging that commissions had become too important to manage via spreadsheets. It was about focus.
When a company chooses to buy, it does so not because the team can’t build, but because it shouldn’t have to. Expertise is expensive. Maintenance is exhausting. And internal tools, unless they’re a core part of your business, rarely keep pace with growth.
The Real Cost of “Make”
On paper, building a custom tool seems cost-effective. There’s no upfront licensing fee. No vendor lock-in. No onboarding headaches. But these savings are often eclipsed by hidden costs:
1. Time
Every hour spent debugging formulas is an hour not spent closing deals, refining strategy, or onboarding reps. The opportunity cost of internal development compounds quickly, especially when systems touch compensation.
2. Expertise Gaps
Effective commission systems require a blend of domain knowledge, financial rigor, and technical precision. It’s rare to find these in a single person, and even rarer for such a person to be available part-time. Most internal systems are built by generalists who learn as they go—an admirable effort, but risky at scale.
3. Change Management
As businesses evolve, so do compensation plans. Updating a homegrown tool every quarter means revisiting logic, validating changes, and ensuring historical data integrity. This isn’t just about software—it’s about documentation, transparency, and governance.
4. Trust and Transparency
Salespeople live by their paychecks. When their earnings depend on systems that are hard to understand or easy to break, confidence erodes. Even the perception of unfairness can damage morale. Purpose-built tools offer not just structure, but also audit trails and clear visibility.
The Strategic Case for “Buy”
When executed well, purchasing software isn’t about offloading responsibility—it’s about redefining roles. Buying a solution doesn’t just solve a problem; it forces a company to formalize its logic.
1. Rule Definition Over Rule Discovery
One of the hidden benefits of buying software is that it demands specificity. Vendors ask pointed questions: What triggers an accelerator? When does a clawback apply? Who approves exceptions? This requirement to define rules, instead of improvising them, leads to better internal alignment.
2. Structure and Support
Off-the-shelf software comes with built-in validation, error checking, and user support. This doesn’t just reduce errors—it helps teams operate with greater confidence. It also standardizes processes across departments and regions.
3. Focus
Perhaps the most undervalued benefit of buying is the freedom it provides. Freed from the burden of maintaining bespoke tools, teams can reallocate attention to growth initiatives. Product teams build features. Sales teams close deals. Finance teams analyze insights instead of troubleshooting inputs.
The Cultural Hurdle: Pride in Building
Choosing to build a tool carries a sense of pride, especially in fast-growing startups. There’s a belief that scrappiness is synonymous with strength—that if something can be built in-house, it should be. But that mindset often mistakes motion for progress.
There’s nothing wrong with building your own tools—until those tools start to become obstacles. Pride can become a trap when it prevents organizations from moving forward. Strategic leaders recognize when it’s time to let go of internal creations, no matter how much effort they required.
Asking the Right Question
The heart of the “make vs. buy” dilemma isn’t about ability. It’s about intent.
The question is not: “Can we build this?”
It’s: “Do we want to be in the business of building this?”
For the team behind the commission tracker, the answer became clear. They didn’t want to be in the business of managing comp software. They wanted accurate payouts, scalable logic, and peace of mind. Buying wasn’t the easy choice—it was the strategic one.
The Takeaways
For any organization evaluating whether to make or buy, here are the guiding principles that emerged from this journey:
- Build when the problem is unique, the expertise is available, and the tool is core to your differentiation.
- Buy when the problem is common, the risk of error is high, and the internal bandwidth is low.
- Trust is a business asset. Systems that handle money, especially incentives, must be trustworthy by design—not patched together on faith.
- Every tool is a product. Even internal ones. And every product needs maintenance, support, and accountability.
Final Word: It’s Okay to Let Go
There’s a tendency in tech teams to treat scrappy builds as badges of honor. But not every spreadsheet deserves a legacy. Sometimes the most courageous, forward-looking thing a team can do is admit the spreadsheet is done, the edge cases are winning, and it’s time to scale.
Letting go isn’t failure. It’s focus.
And in business, focus is often the difference between good and great.
