Is Provisioning Policy the best approach to handle below

Hi All,

I have a scenario involving a Web Services connector where all CRUD operations are configured under HTTP Operations. The Create Account and Attribute Sync sections are mapped accordingly, and everything is working as expected, except for one particular scenario.

When the firstname attribute is empty, the downstream API returns an error. For this particular downstream system, the requirement is to send # as the value whenever firstname is empty.

The firstname attribute is mapped to the firstname identity attribute in the Create Account configuration and is also enabled in Attribute Sync.

To address this, I decided to handle the transformation through the Create and Update Provisioning Policies. I followed these steps:

  1. Using the API, I updated the Create Provisioning Policy to include a transform for firstnameand covered all other mappings. This worked as expected for account creation.

  2. However, updates were still failing.

  3. I then unticked all attributes under Attribute Sync and created an Update Provisioning Policy, using the same rules and attribute mappings as the Create Provisioning Policy, including the transformation to handle an empty firstname.

With this configuration, both account creation and updates appear to be working as expected.

I also noticed a difference in the provisioning events:

  • When Attribute Sync is enabled for all attributes, the events behave differently.

  • With the attributes unticked and the Update Provisioning Policy handling the updates, the event shows a single successful downstream update entry, with no errors.

I also verified that the downstream system was successfully updated.

My questions are:

  1. Is this a recommended approach for this type of requirement, i.e. disabling Attribute Sync and managing all attribute updates through the Update Provisioning Policy?

  2. By unticking all attributes under Attribute Sync, is there a risk of missing any attribute updates?

  3. Given that my Update Provisioning Policy covers all the attributes previously mapped through Attribute Sync, including the required transformation to replace an empty firstname with #, should this approach be sufficient?

I would prefer not to introduce an additional identity attribute just to handle this downstream-specific requirement.

Would appreciate any suggestions or alternative approaches.

Also note we got ISC and for above connector we got BP rule defined as well to do other things which I did not touch for above need.

Regards,

Your approach can work, but I would not recommend disabling Attribute Sync for all attributes unless you have verified every update path.

In SailPoint ISC, Attribute Sync is specifically designed to detect differences between configured identity attributes and existing correlated account attributes, then provision those changes automatically.

For your scenario:

  • Using a transform in the Create Provisioning Policy for firstname = null/empty → "#" is reasonable.
  • If the Update Provisioning Policy reliably receives all required attribute changes and your testing confirms it, your current design can work.
  • However, disabling Attribute Sync means you are removing its normal automatic synchronization behavior. Therefore, test changes originating from aggregation/identity refresh, lifecycle changes, and other provisioning events, not just direct updates.
  • Since # is purely a downstream requirement, I agree that creating another identity attribute just for this is unnecessary.
  • Since you already have a Before Provisioning (BP) rule, another clean option is to handle only the firstname null/empty substitution there, while leaving the existing Attribute Sync design intact. Just ensure this does not conflict with the existing BP rule logic.

My preference: keep Attribute Sync where possible and handle the downstream-specific null → "#" conversion at the provisioning/connector layer rather than changing your overall synchronization model.

Hello Lalitha. Since you already have a BP rule, I would build on that. I would not recommend disabling Attribute Sync for all attributes. It risks missing identity-driven updates, and an Update Provisioning Policy is not an equivalent replacement.

A few things I would check:

  1. Create Account mapping: Confirm firstname is mapped directly to the identity attribute. If your transform replaced that mapping, it may no longer qualify for Attribute Sync. Move the null/empty → # conversion into your rule.
  2. Provisioning plan: When firstname becomes blank, check whether a Modify request containing its AttributeRequest is generated. If present, your Before Provisioning rule can replace the blank value with #.
  3. HTTP payload: If the Modify request exists but the JSON omits firstname, consider a Web Services Before Operation rule. Neither rule can trigger provisioning if no Modify operation exists.
  4. Sync behavior: Keeping firstname synchronized preserves its update trigger, but if the target returns # while the identity contains null, repeated synchronization may occur. SailPoint cautions against synchronizing rule-modified values.

I would test populated → blank, blank → populated, and another attribute change, followed by aggregation and identity refresh. Check for missed updates or repeated Modify events. Also confirm whether the target requires a complete update payload before removing any Update policy mappings.

My suggestion: Keep Attribute Sync for unaffected attributes and handle firstname separately. If its value mismatch causes repeated updates, you will need aligned comparison values or another reliable update trigger. No additional identity attribute is needed solely for outbound formatting.

Hi Harish,

Thanks for the detailed response. I generally agree with your explanation, and it makes sense from a conventional provisioning perspective.

However, my observations in this particular scenario are slightly different.

We have a Web Services connector for D2L. As you know, one of the challenges with this type of connector is that attributes that are not included in an update can sometimes go missing, potentially resulting in unintended updates to the target system.

To address this, we introduced a Before Provisioning (BP) rule for the D2L connector from the beginning. Its primary responsibility is to check for missing attributes and, where necessary, populate them using the corresponding Identity attributes before the provisioning request is sent to D2L.

Even before making the FirstName change, the biggest issue I observed with this connector was the repeated attribute synchronisation events.

For example, almost every day, we were seeing events where Attribute1/2/3 had a previous value of null and a new value of xxxx as part of Attribute Sync. The aggregation summaries were also showing thousands of updated records. The truth is that value was not null but…

I believe this abnormal behaviour is related to the issue I described with the BP rule.

Although we run aggregations against D2L, we don’t make any direct changes to D2L outside SailPoint. Considering this, I decided to try a different approach for firstname empty replace with # so that it will resolve both:

  • Configured the Create Provisioning Policy with the required transformations.

  • Configured the Update Provisioning Policy with the complete set of required attributes.

  • Removed Attribute Sync from the connector.

Since making these changes, I can no longer see the repeated synchronisation events. The aggregation summaries are also showing only a relatively small number of required record updates. Additionally, with Attribute Sync disabled, we are no longer seeing those repeated attribute update events.

Given this scenario, I would like to understand the specific circumstances in which attributes might not be sent to the downstream system when Attribute Sync is disabled. My understanding is that whenever a source system change triggers an update, the Update Provisioning Policy is executed and supplies the required attributes.

Considering the inherent challenges associated with Web Services connectors, I am wondering whether moving more of the attribute handling and transformation logic into the Create and Update Provisioning Policies might actually be a better approach.

I would appreciate your thoughts on whether this approach is sound and whether there are any potential scenarios or risks I might be overlooking.

Hello Lalitha. Thanks for clarifying the D2L setup. Given your results, I would keep the current configuration while verifying two things.

  1. Repeated updates: Your BP rule runs during provisioning, not aggregation. For one affected account, compare the raw D2L response, Web Services response mappings, and stored ISC account attributes. Were those null → value changes actually reflected on the ISC account, or only in the sync events? Disabling Attribute Sync stops those events, but does not necessarily fix the original mismatch.
  2. Updates without Attribute Sync: Your Update policy can supply attributes during provisioning, and some values may be re-evaluated during identity refresh. However, this is not a documented replacement for Attribute Sync’s automatic change detection.

I would test:

  1. Change only one authoritative identity attribute, with no other provisioning trigger. Refresh the identity and confirm D2L receives the update.
  2. Repeat for firstname, both populated → blank and blank → populated.
  3. Inspect the actual outgoing JSON to confirm all required fields are present. Do not rely on the provisioning plan alone.
  4. Aggregate and refresh again without changes. Check for unnecessary Modify events.

If these tests pass consistently, your approach may work well for D2L. My main concern is ensuring every identity-only change has a reliable trigger rather than depending on refresh-time policy evaluation.

SailPoint’s Attribute Sync documentation explains the automatic synchronization behavior you lose by disabling it.

Hi Harish

The /account POST API calls (which we frequently use in addition to source aggregations) appear to handle both null → value and value → null changes correctly. I observed in events one entry denoting the update with reason IdentityRefresh

However, I have some concerns about how changes are handled when they are detected through source aggregation because for trusted source aggregation I can see other sources got the updates and reason as attribute sync but not for this.

If my understanding is correct, when a source aggregation runs, ISC identifies discrepancies between identity and account attributes and, where Attribute Sync is configured, triggers the corresponding sync operation. This then generates a provisioning event, which goes through the normal provisioning process, including BP rules.

My main concern relates to SailPoint’s best-practice recommendation in its Attribute Sync documentation to avoid configuring Rule-Modified Attributes for Attribute Sync:

“Avoid Syncing Rule-Modified Attributes: If your aggregation or provisioning processes modify attribute values through rules, those attributes should generally NOT be configured for attribute sync. This creates a high risk of a sync loop, where Identity Security Cloud repeatedly attempts to resynchronize values that are constantly being altered by rules, preventing them from ever truly aligning.”

If we follow this recommendation and exclude such attributes from Attribute Sync, how do we safeguard against missing updates to those attributes, particularly when changes are detected through natural source aggregation?

For example, I could remove the Update provisioning policy and move the relevant logic into a BP rule. However, this would mean removing the affected attribute (firstname) from Attribute Sync to avoid the potential sync-loop scenario described above.

If we do that, what mechanism would then trigger the provisioning process when firstname changes naturally during a subsequent source aggregation?

Essentially, I am trying to understand the recommended design pattern that allows us do such modifications without loosing changes and importantly, without introducing the risk of Attribute Sync loops.

Hello Lalitha. Your understanding is correct. Attribute Sync can trigger a Modify after authoritative aggregation changes an identity attribute, which then passes through your BP rule. With firstname excluded, that automatic trigger is lost. Your IdentityRefresh events confirm provisioning occurred, but not what triggered it.

I would consider three options:

  1. Native Attribute Sync (preferred): Create a D2L-specific identity attribute (d2lFirstName) that converts blank to #. Map it directly in Create Account and enable Attribute Sync. Ensure D2L aggregation returns the same value and your BP rule does not modify it again. This avoids the specific mismatch that could cause a sync loop.
  2. Keep your current approach: Test firstname-only changes through authoritative aggregation, including blank ↔ populated, followed by a no-change refresh. Confirm D2L receives the updates without repeated Modify events. This may work, but Update policy evaluation is not a documented synchronization guarantee. Consider periodic reconciliation to catch missed updates.
  3. Event-driven workflow: Use Identity Attributes Changed to detect firstname changes during identity processing. An authenticated HTTP integration would then update D2L directly. This bypasses the connector and BP rule, so authentication and payload handling must be managed separately.

The Manage Accounts workflow action cannot update arbitrary account attributes.

My suggestion: Option 1 is the cleanest documented native approach. If avoiding another identity attribute is important, validate option 2 first and consider option 3 if it cannot reliably handle firstname-only changes.

Hi Harish,

Thanks for your feedback.

I agree that creating an identity attribute is probably the cleanest approach to avoid potential loops and other unintended side effects. My only concern is that introducing a new identity attribute for each such scenario could add unnecessary processing overhead. However, I fully understand your reasoning and where you are coming from.

Below are the results of the testing I have conducted using my current approach with UPDATE and CREATE provisioning policies.

  • Null → Value: Working as expected.

  • Value → Null: Working as expected.

  • All other combinations: Working as expected.

For /account update POST calls, everything appears to work as expected, which is the primary driver behind our approach. Each update generates a provisioning event with the reason shown as IdentityRefresh.

However, the account does not appear to get updated when the change is picked up through a trusted source aggregation. My assumption is that this is because I have not configured anything under Attribute Sync.

We generally expect our dynamic updates to SailPoint through the /account API to capture almost all changes, with aggregation acting as a fallback to pick up anything that might have been missed.

Given that SailPoint has two native Identity Refresh jobs running daily, one in the morning and another in the evening, do you think these would eventually reconcile any remaining mismatches?

If that is how it works, I believe the current solution should be sufficient, particularly since normal source aggregation does not appear to trigger an Identity Refresh in this scenario.

As a side note, I also tested an alternative approach using a Before Provisioning rule. I was able to get the logic working and enable Attribute Sync, but the downside is the potential provisioning loop that comes with it.

Keen to hear your thoughts.

Regards,

Your /account POST updates are working, but the aggregation-only test still shows a gap. I would not rely on the twice-daily Identity Processing jobs to reconcile D2L with Attribute Sync disabled. As SailPoint’s documentation explains, aggregation can trigger identity processing, but that does not guarantee target attribute synchronization. Neither scheduled job guarantees it either.

I would suggest two options:

  1. Native Attribute Sync: Use a normalized d2lFirstName identity attribute, mapped directly in Create Account, with Attribute Sync enabled. Ensure D2L aggregation returns the same value and your BP rule does not modify it again. This avoids the specific null-versus-# mismatch.
  2. Keep your current approach: Use an Identity Attributes Changed workflow to detect authoritative changes and invoke a supported D2L update integration. For missed updates or target-side drift, add periodic comparison and remediation. The workflow alone will not catch an unchanged identity with an outdated D2L account.

Which exact /account POST endpoint are you using? SailPoint’s Update Account API supports attribute modifications only for flat-file accounts. Given your concern about additional identity attributes, I would keep the current POST approach for the updates it handles, but add an explicit reconciliation mechanism if aggregation must serve as a reliable fallback.

Hi Harish,

Thanks for your continued support.

I have investigated this a few times and can confirm that source aggregation does not appear to trigger an Identity Refresh. As a result, changes to identity attributes, such as firstname, are not being synchronised back to the account.

However, when I manually trigger the Identity Refresh process, the changes are successfully propagated to the account.

To answer your question, I am using the API below for both account creation and updates, with the full payload provided in each request:

Interestingly, updating an account through this API also triggers an Identity Refresh, which results in the account being updated as expected.

I have also checked the nightly Identity Refresh job, but it does not appear to have picked up the changes either. This makes the behaviour a little confusing, particularly given that manually triggering the Identity Refresh works as expected.

Does this mean that introducing an Identity Attribute, as you suggested, is the most viable option?

My only concern with this approach is that introducing a new Identity Attribute and applying the associated configuration may trigger processing across all identities, potentially resulting in additional processing overhead and performance impacts.

I would appreciate your thoughts on whether there is an alternative approach that would avoid this additional processing while still achieving the desired outcome.

With an account ID supplied, the Create Account API acts as a PATCH, but for a direct-connect source like D2L it updates the ISC account record, not the target, and a later aggregation can overwrite it. So the D2L write is most likely driven by the refresh your call triggers, not by the API. The IdentityRefresh event alone does not establish what generated the Modify, so confirm the mechanism before relying on it.

Test on one identity: change firstname at the source, aggregate, confirm the identity attribute changed, then check whether a D2L Modify was generated. Next, manually refresh the same identity and compare the plans, events, and D2L values. That separates an identity that did not update from an account that did not provision, and shows what manual processing does that aggregation does not. I would not rely on the nightly jobs to reconcile this while Attribute Sync is disabled.

On the design choice:

  1. Dedicated identity attribute: the most reliable native option, since Attribute Sync uses the real provisioning path. The cost is a one-time profile reprocess to populate it, plus ongoing transform and sync evaluation that scales with your volumes. Validate on a small population first.
  2. Avoid a new attribute: an Identity Attributes Changed workflow fires only for identities that actually change, so there is no bulk reprocessing. Route the change to a supported D2L write path, not /accounts/v1 on its own, and add periodic reconciliation for missed updates.

I would identify why the manual refresh works first, then use the dedicated attribute for the cleanest native sync, or the workflow if avoiding the attribute is the priority.

Hi Harish,

Thanks for your reply. Below is a summary of my findings and the options I believe we have moving forward.

Summary of findings

  • I agree that the current API effectively works as a PATCH operation. It updates the ISC account record, triggers an Identity Refresh, which subsequently generates a provisioning event and updates the actual target account. Given that we make these API calls quite frequently using a delta mechanism, most systems remain synchronised well before the nightly aggregation. Therefore, this approach appears to be working safely for now.

  • Based on my testing, source aggregation does not trigger an Identity Refresh. It updates the Identity record but does not update the corresponding ISC account record. Normally, source aggregation would trigger Attribute Sync; however, since we have disabled the relevant configurations, that process is not triggered either. This means we cannot rely on source aggregation for this purpose. I also noticed that the nightly Identity Refresh has not picked up these changes, so I don’t think we should rely on that mechanism either.

  • On a slightly different note, regarding the large number of records previously appearing as updated in the D2L aggregation source summary, I suspect this is because, after aggregating each account, SailPoint triggers Attribute Sync, which then goes through the Business Process (BP) rules again and identifies further mismatches. This could explain the additional updates we were seeing.

Potential options moving forward

As you suggested, I can see the following options:

  1. Retain the current solution for now: Continue using the existing API-based approach, as we invoke these API calls quite frequently, ensuring that changes are synchronised without waiting for the nightly aggregation.

  2. Introduce a dedicated Identity Attribute: Create a new Identity Attribute specifically for this purpose. Although applying this change may trigger processing across a large number of identities initially, we could test its impact in the non-production environment first.

  3. Retain the previous solution but handle the logic within the BP rule: This is technically possible, but I am not particularly keen on this approach due to the potential for unnecessary processing and repeated execution of the same logic.

  4. Introduce a trigger to make a direct D2L API call: This would provide another way to handle the synchronisation without relying on the existing aggregation and Attribute Sync mechanisms.

My preferred approach

Option 2 appears to be the closest to what we are trying to achieve as you suggested.

The proposed approach would be to introduce the dedicated Identity Attribute, remove the UPDATE policy, revert the previous changes, and re-enable the relevant attributes in Attribute Sync.

However, I still have some reservations. Given the inherent behaviour of Web Services connectors, particularly where we reject certain parameters within the BP rule, I am not entirely convinced that this will prevent unnecessary update events from being generated. We may still see a significant number of updates being triggered during aggregation. If so option 3 also an option because already updates are happening for other reason.

I think it would be worth validating this approach in non-production before making any changes in production.