How to govern multiple Salesforce implementation partners on one org
Five rules from a program with five partners and more than 30 developers on one org

To govern several implementation partners on one Salesforce org, the client has to own the repository, the pipeline, the standards and the approval rights. Every deployable change goes through a gated Git workflow, every object has one owning stream, and changes that touch more than one stream are decided in a fixed forum with a decision log. Without these rules each partner optimizes its own scope, and the client pays for the conflicts between them.
A typical setup: a manufacturer hires one partner for Sales Cloud, another for Field Service, a third for the ERP integration, and keeps a few internal developers on top. The problems rarely come from weak partners. They come from uncoordinated changes in a shared org that nobody on the client side owns as a whole.
The largest program I have steered as a client-side architect had more than 30 developers in eight streams, delivered by five implementation partners and internal teams. When I joined, no object had an owner, teams overwrote each other's changes and every partner built by its own conventions. The following five rules got it under control. They need Git, branch protection, written standards and regular reviews, but no commercial tool.
How should changes reach a shared Salesforce org?
Start with a hard rule: no direct changes in integration, UAT or production. Every deployable metadata change, down to a picklist value or a flow tweak, goes into Git, gets a pull request and moves through the pipeline. The few things that cannot be deployed cleanly, such as some org settings or post-deployment data, get a documented manual step with a named approver.
Source control gives reviewers a real change set and gives the client a history of who changed what. It also protects the work: a sandbox refresh wipes out anything that only existed in that sandbox. If you use DevOps Center, the same applies: it works on top of a Git repository, and the gate is the promotion of a work item instead of a pull request.
Back the rule with permissions. Partner developers get admin-level setup and development permissions only in their own development sandboxes. In integration, UAT and production, only the pipeline's integration user deploys. For production incidents, agree a break-glass process up front: a named person, a ticket, and the fix goes back into Git the same day.
For a calibration phase at the start, I reviewed every pull request myself. That does not scale, and it is not meant to. Within two or three weeks it shows what the teams actually do differently, which is the raw material for the standards.
Who owns each Salesforce object?
Conflicts between partners cluster on a few objects. In a manufacturing org that is typically Account, Case, Asset and Work Order: sales, service, field service and the ERP integration all add fields, flows and validation rules to them.
An object ownership matrix has one row per object and names one owning stream. Any other team that wants to change that object agrees with the owner first. Teams can still work on shared objects; someone has simply looked at the whole object before the fourth flow on Work Order goes live. Fields that an interface writes, together with their external IDs, belong to the integration stream, so a field nobody seems to use is not deleted while the ERP still fills it.
The matrix itself is a table in the client's wiki. On GitHub or GitLab, a CODEOWNERS file plus branch protection can require a review from the owning stream for metadata under that object's folder. Flows, Apex classes and Lightning components that act on the object live elsewhere in the repository, so a naming convention with the stream prefix and the human review still have to cover them.
How should shared standards be created?
Every experienced partner brings its own development standards, and most are reasonable. Five reasonable standards on one org still produce an inconsistent system: automation in triggers here, in flows there, a threshold hard-coded in one class and configurable in the next.
Base the first version on the review findings from the calibration phase. In my program it covered about 80 percent of the cases: naming with a stream prefix, one agreed automation pattern per object (one trigger handler, or a set of record-triggered flows with a defined trigger order, not both), and Apex tests that assert results instead of just covering lines. Two rules made the biggest difference: the ownership matrix, and keeping deployable thresholds and feature switches in custom metadata types and translatable user-facing text in custom labels. Credentials go into named credentials, never into either.
It took about three months until the standards were stable. Let the pipeline check what a machine can check: Salesforce Code Analyzer finds patterns such as hard-coded IDs, and the validation deployment runs the Apex tests and enforces coverage. The review covers the rest: whether a design fits the architecture and whether a change respects ownership.
Where are cross-stream decisions made?
The first version of the standards never covers everything. A stream needs a field on another stream's object, or two teams plan a change to the same flow in the same sprint. Without a fixed place, two developers settle it in a chat, and the next pair settles it differently.
We held a Center of Excellence call every two weeks with the technical leads of all streams. Changes that touch more than one stream were raised there with enough lead time. Every binding decision went into a decision log with date, decider and reason, and changes to the standards got a version number.
The call also gives each stream lead a clear rule to take back to the team. A new developer at a partner then learns it from their own lead instead of from a client document.
Who owns governance when partners change?
A partner can write good standards. If one partner sets the rules, though, it decides how its competitors build in the same org. If it also holds the repository, the pipeline and the backlog, every change of partner gets expensive and offers are hard to compare.
So the standards, the ownership matrix, the repository and the approval rights belong to the client. A new partner starts with the same rules, tools and rights as everyone else. A partner who leaves hands over open work, and everything else stays where it is.
The step most programs skip is the handover to an internal owner. In my program, once reviews had moved to qualified reviewers in the streams and the Center of Excellence ran on its own, I trained an internal colleague who has owned the process since. Governance that depends on one external person ends with that person's contract.
How do you know it is working?
Track four signals for three months:
How many objects in the ownership matrix have an owning stream.
How often changes from different teams overwrite each other.
How long a pull request waits for its review.
Whether a review comment keeps coming back, or disappears once it is in the standard.
When late conflicts become rare because new edge cases come up in the Center of Excellence call before anyone builds them, the program is under control.
Frequently asked questions
Can implementation partners deploy directly to production? Only through the client's pipeline. Partner users should not hold deploy rights in shared environments; a break-glass process covers real emergencies.
Who should own the Salesforce repository and pipeline? The client. A partner can operate them, but the account, the access rights and the history stay with the company that owns the org.
How long does it take to establish shared standards? In my largest program, about three months until they were stable. The first version covered around 80 percent of the cases, and the rest came through the Center of Excellence call.
A worked example of the ownership matrix, with a sample table, is in Salesforce object ownership matrix: who owns what?
Share this article
Sources
Practise it
Five questions on Salesforce certifications
Exam-style questions with an explanation after each one. No account needed, and your answers build a weak-topic map once you have one.
Comments
No comments yet. Start the conversation.
Sign in to join the discussion. Your account works across every page.