Distribution Engine

Distribution Engine is an open-source routing framework for Salesforce that uses custom metadata to define routing rules and Flow to execute assignment logic. It supports round-robin, territory-based, and skill-based routing for leads, contacts, accounts, and opportunities. The framework is free, but you build and maintain the routing logic yourself using Salesforce declarative tools.

Official site ↗

Why it ranks here

  • Zero licensing cost: open-source GitHub project with no vendor fees, no per-user charges, and no restrictions on use cases or record volume
  • Metadata-driven design: routing rules are stored in custom metadata, making them easy to version control, migrate between orgs, and update without code changes
  • Community-supported: active contributor base, regular updates, and shared patterns for common routing scenarios

Where it sits

  • More transparent than Traction Complete: you see the full source code and can modify anything; no black-box managed package limitations
  • Less polished than LeanData or Chili Piper: no visual routing builder, no SaaS dashboard, no vendor support; you own the implementation and troubleshooting
  • Stronger on flexibility than native Salesforce assignment rules: supports multi-object routing, complex fallback logic, and custom capacity rules that standard assignment rules cannot handle

How GTM Operations teams use it

  • Deploy the managed package from GitHub, configure custom metadata records for routing pools (round-robin groups, territory assignments), and build Flow processes that reference the Distribution Engine API
  • Define routing logic using metadata: specify object type (Lead, Opportunity), match criteria (territory, industry, account tier), and assignment method (round-robin, load-balanced, territory-based)
  • Monitor routing outcomes using Salesforce reports on assignment history and pool member workload; build custom dashboards to track distribution fairness and queue depth
  • Contribute back to the project: share custom routing patterns, report bugs, or extend the framework with new assignment algorithms

In-depth notes

  • Implementation is fully DIY; plan for 4-6 weeks to configure, test, and deploy routing logic with your Salesforce admin team
  • The framework is capable but requires Salesforce Flow and custom metadata expertise; not suitable for teams without in-house admin skills
  • No vendor support: you rely on GitHub issues, community forums, and internal troubleshooting when routing logic breaks
  • Distribution Engine handles routing only; lead-to-account matching, deduplication, and enrichment are separate concerns you must solve elsewhere
  • Best for teams that want full control, zero licensing costs, and have the Salesforce chops to build and maintain routing infrastructure

Best for

Engineering-savvy RevOps teams, open-source-friendly organizations, or companies with tight budgets that can invest admin time instead of vendor fees

Avoid if

Teams that need vendor support, polished UI, or pre-built routing templates; the framework is a toolkit, not a pre-built solution

Learning guide

Advanced Time to value: 4-6 weeks to first routing flows

Setup

Deploy the open-source package from GitHub, configure custom metadata records to define routing pools (round-robin groups, territory assignments), build Salesforce Flow processes that call the Distribution Engine API to assign records.

First thing to build

Create a round-robin pool in custom metadata with 3-5 reps, build a Flow that triggers on lead creation, call the Distribution Engine assign method, and route the lead to the next available rep in the pool.

What actually matters

  • Custom metadata records (pools, members, assignment methods)
  • Salesforce Flow API calls (assign, rotate, load-balance)
  • Pool member capacity rules (max load, active status)
  • Assignment history tracking (Salesforce reports on pool distribution)

Watch out

Missing fallback logic in Flow leaves unassigned records in limbo with no owner.