Vetting commission automation software? Here’s a handy checklist before your next demo call

You are finally fed up with managing commissions over spreadsheets. Countless hours of manual calculations, broken formulas, spreadsheets that don’t integrate with your sources of commission data, sullen reps who don’t trust your commission payouts…I feel you.

Congratulations on deciding to level up. You have a list of strategic projects that you’d steer once commissions are automated, and for good reason.

However, commission automation projects can go south if certain operational blind spots are not considered during the purchase process. We’ve seen numerous teams go back to spreadsheets 6 months into automating their commissions, and the resulting loss in morale has manifested itself in water cooler conversations for 6 more.

This literature is an attempt to shed light on crucial vetting factors that you must take into account during your ‘research and consideration’ stage. Ignoring these factors would lead to implementation and post-implementation break points, resulting in frustration from inefficiencies.

Without further ado, let’s dive into them

**

Vetting factor #1: Does the software really support data normalization? (aka ‘how deeply does your software integrate across your apps’)

Bombing you with jargon and technical lexicon is definitely not my intention but you’d want to know stuff about data normalization.

Data normalization is the practice of classifying, grouping and organizing diverse data entries to ensure they appear similar across all fields.

Why is data normalization important for automating commissions?

Simply because your data is stored across multiple sources. Your deal data resides in Salesforce and your invoice data resides in Quickbooks. If your marketing division is comp’d on generated pipeline, some of that data resides in Hubspot.

On the customer support front, your NPS data resides in an independent software. So does your CSAT score.

But your commissions are derived out of some or all these KPIs.

For your commissions to be 100% accurate, your software must have the ability to ingest data from all these sources.

Visualizing the intricacies in play?

Here’s an added nuance on top - at its base level, all this data is nothing but tables.

The problem starts when these tables have their distinct meta data, their unique column names and a host of other properties that make tables work.

The bottomline is - a Salesforce table functions very differently than a Quickbooks table, and both tables host deal+invoice data that are inputs for calculating commissions. Your software must have the required features that normalize these incompatible datasets and make them compatible for 100% accurate calculations.

How to avoid this trap: Do not just look at integrations as a check-box item. Go levels deeper and investigate if a software’s integrations normalize datasets across apps. You can accomplish this by working with previous-period datasets hosted in different applications and backtest a software’s calculations for accuracy.

Vetting factor #2: When automating commission calculations, the prospect of trading complexity for simplicity is very alluring. Do not fall for the temptation.

Just this month, we onboarded a couple of customers who had already automated their commissions and moved away from spreadsheets.

The interesting bit - one ditched their software 3 months into launch and another after 2 quarters. Add 45-60 days of implementation and we were looking at crazy costs and time sinks.

The core reason - they achieved 80% automation, not 100%.

80% automation happens when implementing teams trade simplicity of using a step-by-step builder sucked in by their dead simple IF-THEN-ELSE logic. The very nature of such builders necessitates that complex formulas can’t be configured inside the software, leaving room for break points and inaccuracies.

Here’s a reality - complex plans are married to code. I do now know of any software on the block that can write a 10 variable nested logic in a DIY logic builder. Complex plans warrant programming.

Not just that, complexity is also a function of numerous edge cases. Splitting a deal with 3 other reps who worked on that 200,000$ deal across 8 months? Compensating a CS team with tiered commissions and SPIFFs along with deal splitting with the farming team?

These scenarios are hard…nay, impossible…to code with over simplified DIY builders.

How to avoid this trap: While DIY builders are great for configuring simple plans with no riders, look for software that offers the best of both worlds - a DIY builder + a database environment for complex configurations. Ask your vendor if they’ll take upon the mandate to implement complex calculations with their implementation team.

If you go for 80% automation, you’ll soon find yourself back into the spreadsheet grind, because of inaccuracies and edge cases.

Vetting factor #3: Is your software accounting for dynamic shifts as they happen?

Reps leave, shift to other teams (hunters become farmers and vice versa), take on revised OTE targets…the list goes on.

If your commission software is not synced with your HRMS or your CRM or wherever you decide to log these dynamic shifts, you will find yourself updating these changes in the software manually…which defeats the purpose of recruiting the software.

How to avoid this trap: Ask your vendor the mechanics behind how the software keeps a tab on changing sales org structures and an individual’s mandates. If the software does not integrate with your HRMS or CRM, you must be concerned.

Vetting factor #4: Check for true onboarding time from other customers who use your chosen software.

Commission automation software manufacturers bill customers for a predetermined contract period, usually annual, before implementation begins.

Most providers promise a 4 to 6-week implementation cycle but owing to various reasons, implementation cycles go on for 4 to 6 months instead of weeks.

How to avoid this trap: There are two ways

  • Verify implementation SLA claims. Talk to other customers and confirm true implementation timelines. They may differ from marketing claims.
  • Partner with software vendors who

   1. Do not bill you before concluding implementation. This includes configuration, validation, backtesting and onboarding.

   2. Treat implementation as a project with SLAs and offer comprehensive trackers. ElevateHQ uses Rocketlane to communicate all aspects of the implementation project - the milestones, owners of specific milestones and deadlines for each milestone.

Vetting factor #5: Confirm if your software has an accompanying debugger. Also, verify if the debugger has a friendly graphical user interface.

As you work with your commissions software in a business-as-usual setting, you’d be in a lot of conversations with your reps around the usual stuff - commission components in the upcoming payout, deals that contributed, splits that happened, changes that were made to plans midway.

You’d need a handy debugger as your ally.

Here’s why - most implementations are hardcoded in the backend. Without a debugger, you are handicapped in various ways.

You can’t go under the hood to check if any changes were made to commission plans. You’d also not be able to track if rules were adjusted for edge cases. To put it succinctly, you’d have no handy answers to tricky questions.

A GUI debugger allows you to go back in time and see exactly how calculations were impacted for an individual at any point in time. Think of debuggers as step-by-step playback of all the hundreds and thousands calculations that your software computed across a time frame.

Vetting factor #6: Evaluate your software’s dashboarding capabilities. Also, do not get into situations where you have to pay extra $ for a dashlet (true story)

We just onboarded a customer who moved from a big, legacy operator. Of the many problems they faced, one jumped at us.

The software was billing them for custom dashboards with certain KPIs that were specific to their domain.

Baffling, to put it mildly.

Which brings us to the vetting factor - evaluate for the software’s capability to publish custom dashlets on the fly. You never know the new trend line your CRO / CFO can demand from you.

How to avoid this trap: Investigate the types of dashlets that you can build with your software. Also, inquire about the possibilities around importing your custom data into the software.

Vetting factor #7: Investigate the fluidity of your software’s workflows. Rigid workflows lead to systemic breakdowns.

When Elevate runs an RCA of why a commission automation project broke down, more often than not, it is the software’s lack of flexibility behind workflows.

Workflows that allow you to set controls around

  • Who can edit commission plans
  • What is chain of approvals for a payout
  • Who can edit a quota
  • Who will approve a split deal payout

And so on.

If your software hard codes these workflows, you’ll have to manually enter the name of the person who owns a particular leg of a workflow.

Whereas, automation by design, implies that such rules should be tokenized on variables [“sales manager_north_america”] that are ingested from your HRMS.

This means that every time you have a new North America Sales Manager, you should not be going back to your Customer Support team for the change in the workflow. Instead, you must be focusing on important things while letting the software run these changes on auto-pilot in the background.

**

I hope you found this list useful. If you did, spread the word? We are a David in the world of commission automation, competing against Goliaths.

g2-grid

I’d love to hear from you. I am available at akash@elevate.so. I respond to all emails personally <3

Make payouts right every time with ElevateHQ

Move from manual to automated and error-free commission calculations with our platform.

schedule demo banner image