Entitlement management is the part of a platform that decides what a customer has paid for and what each of their people can reach as a result. Authentication tells you who someone is. Entitlements tell you what they are allowed to use, why, and until when.

Most B2B products start with roles and a few feature flags. Then the second pricing tier arrives, then the first enterprise contract with custom terms, and the product quietly grows an entitlement system nobody designed.

I lead product for a customer identity platform that serves more than 200 product lines and a 42,000-license estate. This is the explanation I wish someone had handed me early.

Why your identity provider does not cover it

Identity providers are very good at authentication: sign-in, single sign-on, multi-factor, federation with a customer’s own identity provider. Some will also hand back a user’s groups and roles in one call, which covers simple authorization.

What they are not built to hold is the commercial reality of a B2B business. Which contract does this user’s access come from? Which products and features did that contract include? Which customizations were negotiated? When does it expire, and what happens to forty users when it does?

That logic encodes how your company licenses its products, so it ends up in a layer you own. The pattern I recommend is short: buy authentication, build entitlements. Our platform runs that way, with a commercial identity provider for login and a custom authorization and entitlements layer for everything after it.

Buy authentication, build entitlements: Two layers, two jobs

The objects every entitlement system ends up with

Names vary between companies. The shape does not.

The account. The customer organization. Everything hangs off it, and getting it wrong at the start causes the most expensive cleanup later. Two accounts for one company means two contracts that cannot see each other.

The group. A set of users tied to something commercial, usually a contract or a license. Groups are how access follows the business instead of following individual people.

The license. What was sold: which products, for how many users, for how long. It is the commercial record, and it should read like one.

The package. A named bundle of products or features. Packages let sales sell something stable while product changes what is inside. Without them, every product launch becomes an edit to thousands of licenses.

The customization. The negotiated exception: an extra dataset, a different limit, a feature turned on early. Every enterprise contract has some. The question is whether they are modelled or improvised.

The assignment. The link that gives a user access through a group, license and package. When someone asks why a person can see something, the assignment chain is the answer.

The enrollment. How users actually arrive: invitation links, single sign-on rules, provisioning from the customer’s directory. This is where onboarding speed lives.

Why can this person see this?: The assignment chain

The mistakes each one invites

ObjectQuestion it answersCommon mistake
AccountWho is the customer?Duplicates created during onboarding
GroupWhich users share a contract?Groups built per person, so access never ends
LicenseWhat was sold?Product logic hidden inside the license record
PackageWhat does the bundle contain?No packages, so every launch edits every license
CustomizationWhat was negotiated?Exceptions handled in code, invisible to support
AssignmentWhy can this person see this?No way to trace the chain
EnrollmentHow do users get in?Manual invitations for every new customer

Design for 200 products, not 20

The model that works for twenty products breaks at two hundred unless a few things were separated early.

Keep the commercial object apart from the technical one. A license says what was sold. Permissions say what the software allows. When they are the same record, every pricing change becomes an engineering change.

Make “why can this person see this?” answerable in one query. Support, security and customers will all ask it. If the answer needs an engineer, your support costs grow with every product you add.

Plan for propagation. When a contract changes, every user under it should change with it, through the model, not through a script someone runs at the end of the month.

Treat expiry as a feature. Access that never ends is the default when nobody designs the ending. Contracts end. The access should too.

Where entitlements meet onboarding and AI

Entitlement setup is often the slowest part of enterprise onboarding, because it takes a specialist to translate a contract into accounts, groups, licenses and packages. In my current role I am piloting an AI agent that does that translation. It reads the order, assembles the account, group, license, packages, assignments and enrollment links, and stages the whole setup for a delivery specialist to review and commit. That work takes a person two to five hours per order.

The agent can only do that because the model is explicit. An entitlement system that lives in people’s heads cannot be automated, and it cannot be explained to an auditor either.

If you are a product leader inheriting one of these systems, start by drawing the objects on one page. Where you cannot draw the line between two of them, that is where your next incident is waiting.