If you’re familiar with sales commission software, you already know the benefits:

  • Automate calculations of commissions
  • Better manage commission numbers such as quotas, bonuses, and rates
  • Provide a dashboard to every rep with their goals, statements, and payouts
  • Eliminate manual generation of commission spreadsheets
  • Ensure proper tracking and change management
  • Legally protect your incentive program
  • Deliver compliance with accounting standards (ASC 606)
  • Improve payment accuracy

But how is commission software built? What’s happening under the covers which makes it possible to deliver those capabilities? Let’s take a look at key mechanisms used by incentive software to automate commissions.

A Structured Framework For Commissions

Your commission program probably depends on various numbers such as commission rates, thresholds, draws, quotas, etc. Your commission structure likely also includes rules such as payout formulas, splits, rollups, overrides, etc. Finally, you probably also implement a process to approve plan, review payouts, initiate payroll, etc.

As a whole, your commission structure might look like a confusing “soup” (with various numbers, rules, and workflows floating around). However, there is always some logic behind the apparent madness. Commission software provides a structured framework to represent and fully automate your commission structure. This is what allows you to click and calculate commissions (in one-shot) across all reps.

Commission Calculation Components

Here are some components used by commission software like Sales Cookie to automate calculation of commissions:Capture

Sales Cookie implements a sales processing pipeline to calculate commissions. Eligible sales records go through different processing steps to calculate commissions. Each step comes with a default behavior which works for most commission structures. However, you can customize each step and plug-in your own custom logic.

The sad reality is that most commission software products make limiting assumptions about commissions. For example, they assume there will be a per-deal payout which isn’t always the case. Those poorly designed solutions hard-code commission behaviors, which limits flexibility. As a result, they can only automate a small percentage of real-world commission structures. Sales Cookie, on the other hand, can automate 99% of commission structures because it provides total flexibility at each step.

  • Step 1 – Filtering
    • First, the system must ensure that the right sale records are being processed. For example, if you’re calculating Q1 commissions, you probably only want to process sales within this time period (not Q2 sales!). You may also only want to process paid deals, only “closed won” deals, or apply some other criteria. This first step can be performed by applying a predefined transaction filter (ex: status = closed AND isPaid = true). For more advanced scenarios, you can define your own filtering logic (even a full-fledged script), and decide real-time whether a deal is eligible or not. For example, you could calculate each deal’s margin, and decide if the deal should be eligible based on margin.
  • Step 2 – Valuating
    • Second, we must assign a value to each eligible sale. Often, each deal’s value simply is its revenue. Indeed, many incentive plans are based on revenue. However, if you pay your reps based on how many appointments they book, you need to count events instead. Each deal’s value no longer is its revenue. Instead, each deal counts as 1 point. Other commission structures use profit (or more complex metrics) to value each transaction. Sales Cookie gives you full control over the valuation process. You can run advanced formulas to calculate each deal’s value. For example, you could perform catalog lookups to determine a deal’s value based on its product category and calculated margin.
  • Step 3 – Crediting
    • Third, we need to credit deals to the correct “owners”. Owners could be individual reps, or they could be teams / territories (depending on your plan’s structure). Crediting simply means attribution. For example, if a sale occurred within the Seattle area, it may need to be credited to the “Pacific Northwest” territory. And if Joe and Sarah closed a deal together, they might each receive a portion of the deal (split). Most of the time, the owner will already be specified within your sales data. For other cases, you can leverage a feature called dynamic crediting. An example would be a rule to lookup a product SKU to determine the correct owner. Finally, crediting is the step during which we perform hierarchical rollups.
  • Step 4 – Attainment
    • Fourth, we need to determine attainment towards goals. Very often, attainment is determined by calculating the total value of deals credited to each rep (or team). The sum is then compared to a quota or threshold. For example, if revenue is your valuation metric, attainment could be each rep’s total revenue. If the number of booked appointments is your metric, attainment could be each rep’s total count. Sales Cookie supports more exotic ways to determine attainment. For example, if you wanted attainment to be based on the average call duration of booked appointments, you could do this. Or if you wanted to rank reps based on profit (ex: sales contest), you could also do this.
  • Step 5 – Rewarding
    • Fifth, we need to calculate and assign payouts. Often, attainment will impact payouts. Many incentive plans have multiple attainment bands. Attainment bands can have different accelerators, bonuses, commission rates, etc. Sales Cookie can handle all those scenarios. Note that the rep who was credited with a sale isn’t necessarily the person payouts should be assigned to. For example, you could assign rewards to their managers. Or you could decide that payouts should be shared with team members. In some cases, rewards are global (ex: cash bonus). In other cases, rewards are per-transaction (ex: per-deal commission). Sales Cookie lets you calculate payouts in sophisticated ways using advanced formulas and scripts. You can even execute SQL queries, which run on a virtual set of sales transaction credited to each rep (or territory).

Finally, commission software implements a giant iteration loop. In your configuration, all you need to make sure is that all 5 steps are configured correctly. Once configured, the system calculates payouts across all reps in one-shot. This means you no longer need to manually generate commision spreadsheets one at a time. Even better, Sales Cookie uses parallel processing within the Microsoft Azure platform. Most calculations therefore run very quickly.


Time-Dependent Variables

As previously discussed, your commission structure likely includes various numbers such as rates, thresholds, quotas, bonuses, salaries, variables, etc. One aspect which complicates things a bit is variability of numbers over time. In most real-world environments, commission-related numbers change all the time. For example, rep quotas could change as they leave Q1 and enter Q2.

To bring order to this chaos and automate calculations, Sales Cookie provides time-dependent custom variables. In Sales Cookie, each commission-related number is tracked as a time-dependent variable. You can define variables on users, on teams, on plans, or globally.

Each variable is assigned a name (ex: @@Quota), and can take different values for different time periods. In your configuration, you simply provide values, and then refer to the variable name. Sales Cookie automatically pulls the right value for the variable based on the time period you’re calculating for.

For example, let’s say you have a quota like this:

@@Quota January February March
James Cookie 100,000 110,000 120,000
John Bartlett 200,000 220,000 230,000
<another rep>

We can define a variable called “@@Quota” like this:Capture

Now this variable can be referred to anywhere – for example in a per-transaction formula like this:Capture

That’s all your have to do within your configuration! When you run a calculation, the system automatically goes through all 5 processing steps, and calculates the correct commission for each eligible deal. The formula above will lookup the correct value of @@Quota for each rep and for your chosen calculation period.

One more thing. Some of your reps may transition into new roles mid-period. They might also join a new team. Here too, Sales Cookie lets you specify effective dates to define team membership and plan eligibility.


Finally, commission software tracks all changes made to your numbers and configurations. This can be done using an audit log and other techniques. For example, Sales Cookie takes a full snapshot of your configuration each time you run a calculation.


Storing Commission Data

Commission software must be able to store things in a database – payouts, users, teams, etc. Key entities include:

  • Users
    • This table stores authorized users and their roles
    • Users could be full admins, limited admins, or payees
    • Example: Joe and Jane are both payees
  • Teams
    • This table stores territories and teams
    • This table also records your team hierarchy
    • Example: team Oregon and Washington are under team NorthWest
  • Transactions
    • This table stores all sales events (orders, opportunities, invoices, etc.)
    • Example: order #123 from SalesForce
    • Example: invoice #abc from QuickBooks
  • Plans
    • This table stores incentive plans and their configuration
    • A plan is a commission component (“a way to calculate commissions”)
    • Example: [AE quarterly bonus]
  • Calculations
    • This table stores all calculations
    • Each calculation represents the submission of a plan for a given time period
    • Example: [AE quarterly bonus] > [Q2 calculation]
  • Calculation Credits
    • This table tracks attribution of transactions to users or teams
    • Each record points to a transaction and credited entity
    • Example: Joe was credited with order #123 within calculation [AE quarterly bonus] > [Q2 calculation]
  • Calculation Commissions
    • This table tracks per-transaction commissions (for plans using this model)
    • Each record points to a payee and calculation credit
    • Example: Jane should be paid $10 for order #123 within calculation [AE quarterly bonus] > [Q2 calculation]
  • Calculation Payouts
    • This table tracks payouts (in aggregate) per payee
    • Each record points to a payee and credited entity
    • Example: Jane should be paid $593 for 2540 orders credited to Joe within calculation [AE quarterly bonus] > [Q2 calculation]


Sales Cookie provides the ability to combine transaction data from multiple data sources – each with different fields. We call this concept a data pool. For example, you could import opportunities from SalesForce, plus invoices from QuickBooks, plus appointments from a CSV file. All records can be manipulated individually – or processed together while still retaining their original fields.

Equipped with the right schema, we can view commission data in an infinite number of ways. Here is a simple report we generated using Microsoft Power BI by typing a simple natural language query (“total commission payout by beneficiary email by plan“). Can your current commission software do that?


A Commission Workflow Engine

Finally, you probably implement core commission-related workflows such as:

  • A user enrollment workflow, where reps must agree to terms and conditions to become eligible
  • A plan approval workflow, where compensation administrators design incentive plans, test outcomes, and deploy them
  • A statement verification workflow, where compensation administrators verify calculated payouts before release
  • A manager approval workflow, where managers have an opportunity to review and approve statements

Sales Cookie implements such core workflows to reduce administrative overhead. Here is an example of a simple manager approval workflow. The interface is designed to be intuitive. All your managers need to do are toggle approval statuses.


Please note that many organizations implement custom workflow rules in addition to core commission workflows:

  • Some have unique escalation or reminder policies
  • Some require reps to first approve statements, then managers
  • Some require managers to first approve statements, then reps
  • Some require multi-level approval (ex: manager then VP)
  • Etc.

Even though commission software automates core commission workflows, infinite variations are possible. Organizations with custom approval workflows should consider adopting a general-purpose workflow solution (ex: Nintex, K2, etc.). This can then be applied to other approval workflows such as procurement, travel, vacations, etc.

In Conclusion

Sales commission software such as Sales Cookie provides:

  • A structured yet extremely flexible framework to calculate commissions
  • Time-dependent variables to capture all commission-related numbers
  • A data schema to store every aspect of commission calculations
  • Core commission management workflows to reduce administrative overhead

Visit us online to learn more and automate your commissions!