Reaction to Ping's roadmap: more features, same old complexity?

Having spent the last quarter architecting a custom integration between our internal HR system and PingOne for Customers (Ping1C) to automate user lifecycle management, I find myself with a conflicted perspective on their published roadmap. The promised features—enhanced CIEM capabilities, deeper SaaS application templates, and improved developer portal analytics—are undoubtedly valuable on paper. However, my primary concern remains unaddressed: the intrinsic architectural complexity that turns even straightforward automation into a multi-layered puzzle.

The core issue isn't a lack of functionality, but the cognitive overhead required to wield it. For instance, provisioning a user to a simple SaaS app via SCIM often requires orchestration across:
* The Ping1C directory schema
* Attribute mapping policies, often with custom expressions
* The provisioning configuration itself, which has its own logic layer
* External connection configuration (OAuth, API keys)

While powerful, this dispersion means building a reliable integration demands deep, simultaneous knowledge of several admin consoles. The roadmap's new features appear to be additions to this existing complex structure, not a simplification of it. My team's integration, which should have been a week's work, took three because we had to navigate and debug across these discrete layers. The code snippet below, a small part of our custom SCIM connector logic, illustrates the kind of non-standard workaround we had to implement just to handle a custom attribute transformation—a process that should be trivial in a visual mapper.

```javascript
// Example: Custom logic needed in Ping1C's "Attribute Mapping" to format a manager reference
// This had to be placed in the 'Advanced Expression' section, not a simple mapping.
if (input.department == 'Engineering') {
// We had to construct the SCIM 'manager' complex attribute manually
output.manager = {
'value': getUserIdByEmail(input.managerEmail),
'$ref': buildUserRef(output.manager.value),
'displayName': input.managerName
};
} else {
output.manager = null;
}
// This then feeds into the separate provisioning policy configuration...
```

My question to the community is this: Are others observing a similar trend? Does the roadmap's "more features" approach resonate, or are you also hoping for a "less complexity" parallel track that consolidates and simplifies the integration surface area? Specifically:
* Have the newer CIEM or IGA features tangibly reduced your integration workload, or simply added another module to configure?
* Is the developer experience, particularly with their REST APIs and SDKs, converging towards a more unified model?

I worry we're getting more powerful lego blocks without a clearer instruction manual, or worse, with a more fragmented box of specialty pieces. The engineering cost of integrating Ping remains high, and I see little in the public communications that suggests a fundamental re-think of that experience.

API first.