A one object per directory model avoids precedence conflicts because each import has a single source of truth, but it increases the number of objects and export rules to manage. A shared object model reduces object sprawl and can simplify multi-export scenarios, but it requires careful precedence design and can be harder to maintain as the environment grows.
How the two models differ in object ownership and conflict handling
A one object per directory model gives each connected directory its own record, so imports do not compete to overwrite the same data. That makes precedence simple, because the source of truth is local to each import. The trade-off is that the system carries more objects, more mappings, and more export-specific configuration to keep aligned over time.
A shared object model consolidates multiple exports into one record, which reduces duplication and can make administration easier when the same person object must appear in several targets. The cost is that precedence rules become part of the design itself: every incoming change has to be evaluated against other sources, and a weak rule set can produce stale or inconsistent data.
Why the scaling and maintenance profile is different
The main operational difference is not just how many objects you store, but how much ambiguity you allow into the model. Per-directory objects scale by multiplication, so the burden tends to show up in inventory, lifecycle management, and export orchestration. Shared objects scale by coordination, so the burden shifts toward merge logic, conflict resolution, and careful change control.
That means the better choice depends on what your environment is optimised to absorb. If directories are intentionally separate and their exported attributes should remain isolated, per-directory objects reduce accidental cross-talk. If the same business identity must be projected into several downstream systems, a shared object can be cleaner, but only if attribute ownership and precedence are explicitly documented.
How to choose the safer pattern for your directory landscape
Use one object per directory when you want the lowest ambiguity and the cleanest source-of-truth boundary. Use a shared object model when the business need is to reuse the same identity record across multiple exports and you can tolerate more complex precedence rules. In practice, the deciding factor is whether data isolation or operational simplicity matters more for the connected systems.
If the environment has many integrations, frequent attribute updates, or overlapping owners, the shared model can become fragile unless governance is tight. If the environment is small or the directories represent genuinely distinct populations, separate objects are usually easier to reason about and recover when something changes unexpectedly.
Practitioner Guidance
What to verify: Confirm which attributes are owned by which source before choosing a shared model, and make sure precedence is deterministic for every exported field. If two systems can update the same attribute, the model should state exactly which value wins and under what conditions.
Decision rule: If avoiding collisions and keeping each import independently understandable is the priority, favour one object per directory. If reducing duplicate records is more important, use a shared object only when you can prove the merge logic will stay maintainable as exports increase.
Practitioner takeaway: The real difference is control of ambiguity, per-directory objects minimise it, while shared objects reduce sprawl but demand disciplined precedence governance.
Related resources from NHI Mgmt Group
- What is the difference between using one fixed AI model and supporting multiple models in the same workflow?
- What is the difference between using one JWT and multiple JWTs in an authorisation request?
- What is the difference between a shared privacy operating model and one team owning every privacy task?
- What is the difference between scoring one model and using aggregated jury scores in an eval?
