There's a specific kind of pride that only automation people know. It's the moment you make a system do something it was never designed to do, and it works.
I had that moment once with Pipedrive. I'd built a commission engine inside it. Not next to it, not in a spreadsheet. Inside the CRM. Every won deal would calculate its own commission, automatically, for both reps on my small sales team.
I was so proud that I walked over and told them about it. I explained, with real enthusiasm, that I'd cracked something even Pipedrive's support team couldn't give me an answer for.
You can probably guess where this is going.
Key takeaways
- A CRM is great at recording what was sold. It's not built to hold commission rules that change over time.
- Glue tools like Zapier and Make are excellent at moving data. They're risky places to keep business logic.
- Before you automate a process, ask what happens the first time a rule changes. That's where most automations break.
- "Manual automation", a fixed manual routine with automation discipline, is a legitimate stage. Sometimes it's faster and more reliable than the real thing.
- Don't announce an automation until it has survived a full month. Trust me on this one.
The setup
At the time I was running a small sales operation on Pipedrive with two saleswomen. Every deal lived in Pipedrive. Every commission lived in Excel. And every month I sat between the two, exporting, matching, calculating, and getting something slightly wrong.
Sometimes I paid a little too much. Sometimes a little too little. Neither was dramatic, but both were awkward, and the awkwardness had a monthly subscription.
So I did what any automation person does when something annoys them every month: I decided the computer should do it.
My logic seemed airtight. The deals are already in Pipedrive. The rep is already on the deal. The value is already there. Why should any of it ever leave the CRM?
What I built
I asked Pipedrive support how to calculate commissions inside the system. Nobody could give me a real answer, because there isn't one: Pipedrive doesn't have a commission feature.
Naturally, I took that as a challenge.
Here's what the "engine" looked like:
- Three helper fields to hold the pieces of the calculation.
- A secondary object that had nothing to do with commissions, borrowed because it gave me somewhere to store things the deal itself couldn't.
- Zapier in the middle (this was before I discovered Make), catching each won deal, doing the math, and writing the results back into Pipedrive. Back and forth, back and forth.
When it ran, it felt like magic. A deal moved to won, and a few moments later a commission number appeared. No export. No spreadsheet. No me.
For about a month.
The day it broke
The first time I wanted to change one rep's commission rate, the whole thing fell apart.
That's the part I didn't see coming, and it's the part I now see in almost every automation people show me. I had built something that worked perfectly for the world as it was on the day I built it. A commission plan isn't that world. Rates change. People join. New products appear. And every one of those changes needed the engine to understand something it simply had no concept of: that a rule can be valid until a certain date, and a different rule after it.
The rate lived in one place. The history lived nowhere. Change the rate, and the numbers stopped making sense.
The results had already been only half accurate on a good day. Now they weren't accurate at all.
The embarrassing part
Remember the proud announcement?
The two of them saw it fail. The magic commission engine their manager had personally bragged about, the one that had outsmarted Pipedrive support, was now producing numbers nobody could trust.
I wanted to dig a hole and climb into it.
Luckily we had a good relationship, and they forgot about it pretty quickly. I didn't.
Back to Excel, and a new term
I tried to maintain it for a while, and then I gave up. Every fix created a new edge case. Every edge case needed another field or another Zap. I went back to Excel very quickly, and honestly, with some relief.
That's where I came up with a term I still use: manual automation.
Manual automation is a manual process run with the discipline of an automation:
- The same export, from the same saved filter, every month.
- The same template, with locked formulas.
- The same checklist, in the same order.
- One person responsible, and one place where the final number lives.
It sounds like a step backwards. In practice, it's often faster and more reliable than a fragile automation, because when something changes, a human notices. A Zap doesn't.
I still recommend it to people at the stage I was at. It's not the end state. It's an honest middle.
What I'd tell myself today
1. Run the "first change" test before you build
Before automating anything with rules in it, ask: what happens the first time a rule changes? A new rate, a new rep, a new product, a mid-month correction. If the answer is "I'll update the automation," you're building a maintenance job, not a system.
2. Keep data and rules in different places
A CRM is the right place for deals. It's the wrong place for commission rules, because commission rules need history: this rate applied in March, that one from April. Pipedrive fields don't know what month it is.
3. Use glue tools for moving data, not for thinking
Zapier and Make are brilliant at "when X happens, send it to Y." They get fragile when the logic in the middle grows, because nobody can see the whole thing at once, including the person who built it.
4. Announce after a month, not before
The first month is where every edge case shows up: a deal reassigned, a value corrected, a deal won on the 31st. Let your automation survive that before you tell anyone it exists. Especially the people it pays.
If this existed back then
This story is a big part of why Delta Drive exists.
What I actually needed wasn't a smarter Zap. It was a layer built for commissions: one that reads deals from Pipedrive, keeps each version of the plan with the date it took effect, and calculates every month with the rules that applied in that month. Changing a rep's rate should be a normal Tuesday, not the day the system dies.
It would have saved me a lot of hours in front of Excel formulas. Mostly, it would have saved me from a few very awkward conversations with two people I really didn't want to underpay, or overpay, ever again.
If you're somewhere in the middle of this story yourself, here's how Excel and Delta Drive compare, honestly, including when Excel is still the right answer.
FAQ
Can you calculate sales commissions inside Pipedrive?
Not natively. Pipedrive doesn't have a commission feature. You can store values in custom fields and calculate them with an automation tool, but the logic breaks easily when rates, reps or products change, because Pipedrive fields don't keep a history of which rule applied when.
Can Zapier or Make calculate commissions from Pipedrive?
They can do simple math on each deal, like multiplying a deal value by a fixed rate. Tiered plans, targets, rate changes over time and month-end corrections get complicated quickly, and the logic becomes hard to see and maintain.
What is manual automation?
It's a manual process run with automation discipline: the same saved export, the same locked template and the same checklist every month, with one owner. It's often more reliable than a fragile automation, and a good stage before moving to a dedicated tool.