API-First Commission Management: Why It Matters for Modern RevOps

Every commission tool on the market needs a UI to configure plans. CompCode does not. We are the first programmable commission platform. Every operation is an API call: create a plan, change a tier, assign a rep, run a calculation, generate a statement. The dashboard is one client among many. This post covers what changes for your team when you stop clicking and start shipping.

The problem with click-only commission tools

CaptivateIQ, Spiff, Xactly, QuotaPath, Qobra, Everstage, Performio. Same limitation across the board. To change a commission plan, someone logs into a web app and clicks through screens. No API for plan configuration. No way to script it, version it, test it, or deploy it.

This creates real problems for RevOps teams:

• No version control. When someone changes a tier from 12% to 15%, there is no diff. No pull request. No review process. Often, no record at all beyond "the plan looks different now."
• No testing. You cannot dry-run a plan change against historical data before deploying it. You click Save and hope the numbers are right. If they are wrong, reps see incorrect commissions, trust erodes, and you spend days debugging.
• No bulk operations. Need to update 20 plans for a new fiscal year? You click through each one manually. Need to roll out the same plan structure across 5 entities? Copy, paste, pray nothing was missed.
• No automation. Plan changes cannot be triggered by events: a new pricing model, a territory realignment, a mid-quarter SPIF. Every change requires a human in the UI.
• Vendor lock-in. Your plan logic lives inside a proprietary system. You cannot export it, inspect it, or migrate it without manually recreating every rule in a new tool.

These tools were built for a world where plans changed once a year and one person managed them. That world is gone. Modern SaaS companies change plans quarterly, run SPIFs monthly, and operate across multiple entities with different comp structures. The click-only model does not scale.

What programmable actually means

"API-first" has been diluted by every vendor who bolts a read endpoint onto a UI-first product and calls it modern. Programmable is sharper. It means every operation in the dashboard exists as an API call, and the operations that matter most (create a plan, change a tier, assign a rep, run a calc) work through the API exactly the way they work through the UI.

In CompCode, this means:

• POST /api/plans to create a new commission plan from a JSON config
• PATCH /api/plans/:id to update a plan (automatically creates a new version)
• GET /api/plans/:id to retrieve the full plan config, including version history
• POST /api/assignments to assign reps to plans programmatically
• POST /api/quotas to set targets for any rep, plan, period, and measure
• POST /api/commissions/simulate to dry-run a calculation without creating real events
• POST /api/commissions/recalculate to recalculate commissions after a plan change

The dashboard exists and is fully functional. But it is a UI layer on top of the API, not a replacement for it. Anything you can do in the dashboard, you can do with a curl command.

The Benefits of Commission Plans as Code

Version Control

When commission plans are JSON configs, they can live in Git. A plan change becomes a pull request. Your RevOps team reviews the diff: "tier 2 rate changed from 12% to 15%, effective Q3." The change is approved, merged, and deployed via API. CompCode also versions plans internally. Every PATCH creates a new version with a timestamp, author, and change message. You have two layers of audit trail: your Git history and CompCode's version log.

Automated Testing

Before deploying a plan change, you can simulate it. Send POST /api/commissions/simulate with historical deal data and the new plan config. Compare the output to the old plan. See exactly which reps would be paid more, which would be paid less, and by how much. This is not a spreadsheet exercise, it is a deterministic test that runs against your actual engine.

curl -X POST https://app.compcode.ai/api/commissions/simulate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "planConfig": {
      "rules": [{
        "name": "Updated ACV Rate",
        "measure": "closed_won_revenue",
        "attainmentPeriod": "quarterly",
        "tierBy": "attainment",
        "tierMode": "full_rate",
        "tiers": [
          { "tierIndex": 0, "minThreshold": 0,   "rate": 0.10 },
          { "tierIndex": 1, "minThreshold": 1.0, "rate": 0.18 }
        ]
      }]
    },
    "repId": "rep_001",
    "period": "2026-Q2",
    "dryRun": true
  }'

The response shows what the rep would earn under the new config without writing any commission events. Run this for every rep on the plan. If the numbers look right, deploy. If not, adjust the config and simulate again.

Bulk Operations

New fiscal year, new plans for all teams? Script it. Loop through your plan configs, POST each one, assign reps, set quotas. What takes a week of clicking in CaptivateIQ takes 20 lines of code with CompCode. Multi-entity companies can template a base plan and deploy variations per entity with minor config changes.

CI/CD Deployment

Commission plan deployment can follow the same workflow as software deployment. Store plan configs in your repo. On merge to main, a CI pipeline validates the config (Zod schema validation catches malformed plans before they deploy), runs simulations against test data, and calls the API to update the live plan. Rollback is a PATCH with the previous version's config.

A Real Example: Updating a Tier

Here is a concrete scenario that happens in every fast-moving SaaS company: your VP of Sales decides the accelerator rate above quota should increase from 15% to 18% for Q3. In a UI-only tool this is a 15-step ceremony with no audit log. In an API-first tool, it is a single PATCH request with a change message that becomes the audit log itself. The contrast below makes the difference concrete.

In a UI-only tool (CaptivateIQ, Spiff, Xactly):

1. Log into the admin dashboard
2. Navigate to Plans
3. Find the correct plan (hope there are not 30 plans with similar names)
4. Click Edit
5. Find the tier section
6. Locate the correct tier (hope you change the right one)
7. Change 15 to 18
8. Click Save
9. Hope nobody else was editing the plan at the same time
10. Hope the change takes effect on the right date
11. Hope it does not retroactively recalculate deals you did not intend to change
12. Email the team that the plan changed
13. Three days later, a rep asks why their commission looks different
14. Open the plan, try to figure out what changed and when
15. No audit log. Open a support ticket with the vendor.

In CompCode:

curl -X PATCH https://app.compcode.ai/api/plans/plan_abc123 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "rules": [{
      "name": "ACV Rate",
      "measure": "closed_won_revenue",
      "attainmentPeriod": "quarterly",
      "tierBy": "attainment",
      "tierMode": "full_rate",
      "tiers": [
        { "tierIndex": 0, "minThreshold": 0,   "rate": 0.10 },
        { "tierIndex": 1, "minThreshold": 1.0, "rate": 0.18 }
      ]
    }],
    "changeMessage": "Increase accelerator from 15% to 18% per VP Sales Q3 directive"
  }'

The API creates a new plan version. The old version is preserved. The change message is logged. The version history shows exactly what changed, when, and why. If someone asks in three months, you GET /api/plans/plan_abc123 and read the version log.

Who Benefits Most

RevOps teams who manage more than 5 plans get the most leverage from API-first commission management. The manual overhead of UI-based tools compounds with every plan, every entity, every quarter. API-first design makes the marginal cost of an additional plan close to zero.

Engineering-adjacent teams that already think in terms of configs, deployments, and version control benefit immediately. If your RevOps team uses Terraform for infrastructure, they will immediately understand commission plans as code. The mental model carries over.

Multi-entity companies running different comp structures across geographies, business units, or product lines win on automation. Template a base plan, override the variables per entity, deploy via script. No clicking through the same UI 12 times. The same logic runs in 12 different configurations.

Fast-moving startups that change plans frequently benefit most from speed. Monthly SPIFs, quarterly restructures, mid-year pivots. When plan changes take minutes instead of days, you can iterate on compensation strategy the way you iterate on product. Comp becomes a lever, not a bottleneck.

Ready to see real plan configs? Check out 5 Commission Plan Examples for SaaS Sales Teams. Using Attio as your CRM? See our complete Attio integration guide. For the full API reference, visit the documentation, and see pricing for plan details.