Skip to content

Blog

Provisioning and deprovisioning: one process, two ends

Provisioning and deprovisioning are two ends of one record of who has what. How to keep that record, handle movers, and make offboarding a simple lookup.

· 8 min read

Provisioning and deprovisioning are the two ends of one process: provisioning gives a person accounts and access when they join or change role, and deprovisioning takes that access away when they leave or move. Both read from one record: who has what, granted when and why. Keep that record at the moment you grant access, and removing it later is a lookup rather than an investigation.

Most small companies treat them as separate chores, done by different people at different times. That is why onboarding mostly works and offboarding mostly leaks. This post is about designing them as one process, so the work you do on someone's first day is the checklist for their last.

The two ends

Provisioning happens at a moment everyone is paying attention. A new person starts, they need tools, and if something is missing they say so within the hour. The feedback is immediate. User provisioning covers that end in detail.

Deprovisioning happens when attention is elsewhere. The person is gone, and nobody complains about access that still works. The only feedback is a bill, an audit question or an unpleasant surprise, often months later.

That asymmetry is why deprovisioning is harder. It is not technically harder; clicking Deactivate is easier than choosing a role. It is harder because nobody asks for it: no ticket arrives when a leaver's access is still live. It depends on what was given, and you can only remove what you know about, while most of what was given was never written down. Access accumulates, so someone who has been around for three years has their onboarding tools plus every project, trial and "just for now" admin role since. And some access is invisible: tokens, shared passwords and accounts under personal emails do not show up in your directory.

What is deprovisioning? goes deeper on the removal end alone, including the difference between deactivating and deleting.

The record in the middle: who has what

The fix for all four problems is the same: a record, kept as access is granted, that the removal can be read from.

It needs a row for every account, not every person:

PersonToolAccount emailRoleGranted byDateWhy
Alex ExampleGitHub[email protected]Member, web teamEngineer bundle2026-03-02Role
Alex ExampleAWS console[email protected]Read-onlySam (CTO)2026-05-14Incident review
Alex ExampleFigma[email protected]ViewerEngineer bundle2026-03-02Role
Jo FreelanceFigma[email protected]EditorPriya (design)2026-06-01Contract to 2026-09-30

Read left to right, it is a provisioning log. Filtered by one person, it is their offboarding checklist. Filtered by one tool, it is that tool's user access review. One record serves all three.

The "why" column is the one people skip and the one that matters most. Access granted by role leaves when the role does. Access granted for a reason ("incident review", "contract to September") should leave when the reason does, and the record says when that is.

The "account email" column matters nearly as much. Jo's row uses an address outside the company domain, which means no search of your directory will ever find it. Writing it down at grant time is the only reliable way to know it exists. Contractor access management covers that case in full.

Reading the record backwards: a leaver

Suppose Alex resigns. Without a record, someone opens every tool they can think of and searches for "Alex". With the record, they filter by Alex and get three rows.

The two bundle rows come out with the role: GitHub and Figma, deactivated on the last day. The AWS row is a one-off, granted by Sam for an incident review in May, and it should arguably have ended in May. It is the row most likely to be missed without a record, and the one with the most reach. Before anything is removed, the record also tells you whose decisions to check: Sam granted the AWS access, so Sam knows whether anything runs under it.

GitHub shows why the order matters. Its help page on removing a member says, as we read it on 27 October 2026, that a removed member's membership data is kept for three months so it can be restored if they are invited back, and that removed members lose access to private forks of the organization's private repositories but may still have local copies. Deprovisioning ends access to your systems. It does not reach into the person's laptop, which is why devices and files sit on a separate checklist.

Designing for removal at the moment of access

Every grant is a future removal. A few habits at grant time make that removal simple.

Use the company email, always. An account under a personal address is invisible to your directory and to any search by name. If a contractor must use their own, note it in the record.

Grant by role where you can. A bundle ("Engineer: GitHub member, Linear, Figma viewer") is a list you can remove as easily as you added it. One-off grants are where leaks start.

Give exceptions an owner and an end. Temporary admin rights, a trial seat, access for one project. Write who asked and when it should end.

Never run the business on one person's token. Integrations should run from accounts the company owns. Otherwise removing the person breaks the integration, and keeping the integration keeps the person.

Avoid shared logins. A password you hand out has no deprovisioning step except changing it for everyone. Shared accounts covers the alternatives.

None of these needs software. They are decisions made in the ten seconds before you click Invite.

Movers: changing roles

Between joining and leaving is the part both processes forget: people changing role. In identity jargon, a mover.

A mover needs provisioning and deprovisioning at once. The salesperson who moves to customer success needs the support desk, and no longer needs the sales tools. In practice the first half happens because they ask for it, and the second half never does, because nobody asks to lose access.

The fix is to treat a move as a diff. Compare the old role's bundle with the new one. Add what is new, remove what is no longer needed, and keep only what is shared. Check the one-off grants in the record too: the admin role they had in the old team's tool should not follow them. The JML process post covers joiners, movers and leavers as a single routine, and user lifecycle management puts the whole arc in one place.

Movers are also where paid seats leak. The sales seat the mover no longer uses is still on the bill until someone removes it. A diff that only adds is a cost increase disguised as a promotion.

Common mistakes

The first is treating the directory as the record. Google Workspace knows who works for you. It does not know who has an account in your CRM, with what role, or that a contractor uses a personal address. Suspending someone there stops Google sign-in; it does not remove the separate account in each tool.

The second is deleting when you meant to remove access. Deactivation keeps history and is usually reversible; deletion often is not. Some tools do not even offer deletion: Slack's SCIM API docs say users cannot be permanently deleted, only deactivated.

The third is keeping the record somewhere only one person can update. A sheet that is right on day one and wrong by month three is worse than no sheet, because people trust it. If invites can bypass the record, they will.

The fourth is skipping the check. After a removal, look again a few days later. Orphaned accounts are mostly removals that someone believed had happened.

Small-team setup

For a team of 5 to 50 on Google Workspace, five pieces are enough.

Google Workspace is the list of people. If they are not in it, they should not be in your tools, except contractors you have recorded. Next to it sits a record of who has what, kept when access is granted. A sheet works if one person owns it and every invite goes through them. Then come bundles per role, written down, even if invites are still sent by hand. Each end gets one trigger: a new account in Google Workspace starts provisioning, and a suspension starts deprovisioning. Finally, a quarterly look at the record against reality, comparing every tool's member list with the rows.

The size of the team changes how much of this is worth formalizing. At five people, the record can be a short sheet and the founder can be the trigger. At fifty, with three or four people sending invites, the record goes stale within weeks unless something keeps it current from the tools themselves.

For the step-by-step on each end, see user provisioning for joiners and the employee offboarding checklist for leavers.

Where SmashSSO fits

SmashSSO keeps the record in the middle and works both ends from it. It reads your people from Google Workspace with read-only access, and its access grid shows who has an account in each tool and with what role, matched by email, with accounts that match nobody in your directory flagged. Access bundles by role invite a person to every tool in the bundle with the right role; role changes and removals run the same way, so a mover is a change of bundle. When someone is suspended in Google Workspace, it alerts you and shows where they still have access.

Changes go through a tool's member API where you have added a token, otherwise through an agent in your own Chrome, which has to be open and can fail when a tool changes its screens; some tools' terms restrict automated use. Steps that would add a paid seat pause for approval, and every change is recorded in an audit log. It is not SSO and has no SOC 2 report. It costs a flat fee from $199 a month, billed annually (pricing).

FAQ

What is provisioning and deprovisioning?
Provisioning is giving a person accounts and access when they join or change role. Deprovisioning is removing that access when they leave or move. Both read from the same record of who has what.
Why is deprovisioning harder?
Because nobody asks for it and it depends on knowing what was given. A new hire complains about missing access within the hour; a leaver never complains about access that still works. Recording every grant at the time makes removal a lookup.
What is a mover?
Someone who changes role inside the company. A mover needs provisioning and deprovisioning at once: the new role's access added and the old role's access removed. The removal half is the one usually forgotten.
How do I track who has access?
Keep one row per account: person, tool, account email, role, who granted it, when and why. A sheet works if every invite goes through one owner; past that, a tool that reads member lists from your tools keeps it current.

Keep reading

Stop paying for a login button.

Sign in with Google Workspace, connect your tools, and see who has access to what in minutes.

Sign up with Google