# Implementing a custom Dx component in Higher Environments

**URL:** <https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891>\
**Category:** User Experience\
**Created:** [October 29, 2026, 9:54am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891 "2026-10-29T09:54:22Z")\
**Posts on this page:** 7\
**Page:** 1

<div class="post-metadata">

**Author:** ![Shaun17501594](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/shaun17501594/32/2598_2.png) [@Shaun17501594](https://forums.pega.com/u/Shaun17501594)\
**Post date:** [October 29, 2026, 9:54am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/1 "2026-10-29T09:54:22Z")

</div>

Hi everyone,

I hope you are doing well.

In a Constellation application, I created a custom DX component in an application that uses SSO authentication. While setting up the DX component, I used a URL specific to the Development environment. I then published the component to the Development environment and created a dedicated ruleset for it.

To migrate this DX component to the Staging or Production environment, would migrating the ruleset alone be sufficient, or would I also need to authenticate the DX component using the URL specific to the respective environment?

Additionally, is there any association between the operator used to authenticate the DX component and the DX component itself? If so, would this association have any impact when migrating the component across environments?

I would appreciate your guidance on the recommended approach.

Thanks,  
Shaun

---

<div class="post-metadata">

**Author:** ![duraisankar](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/duraisankar/32/23517_2.png) [@duraisankar](https://forums.pega.com/u/duraisankar)\
**Post date:** [October 29, 2026, 11:28am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/2 "2026-10-29T11:28:14Z")

</div>

> [@Shaun17501594](#):
>
> Additionally, is there any association between the operator used to authenticate the DX component and the DX component itself? If so, would this association have any impact when migrating the component across environments?

Hi Shaun,

We have created, deployed, and maintained multiple custom DX components through to production and have completed few release cycles using the approach below.

Our source code for custom DX components is maintained in a GitHub repository. We have added configs only to the Development environment, where developers perform testing and validation of the components.

We created a dedicated component application that contains two rulesets:

- A custom ruleset for our organization’s DX components.
- The **ConstellationUIGalleryLib** ruleset downloaded from GitHub.

Once testing is complete, we package the component application as a RAP from Dev and promote it to higher environments using Deployment Manager or by manually importing the RAP when needed.

For bug fixes and new functionality, we follow standard Pega application lifecycle practices by incrementing the ruleset version and promoting the changes through the environments.

Regarding the operator specified in the component configuration JSON, it is only required to authenticate and push to the target Pega instance during development. It is not required in the higher environments after deployment. There is no relation between component and operator, it appears only in audit and history. So, We have created a new operator dedicated for this process.

I am not sure whether it is a ideal or recommended flow, but it worked for us till now. I am also open for opinions and suggestion from others as well.

Regards,

Durai.

---

<div class="post-metadata">

**Author:** ![Shaun17501594](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/shaun17501594/32/2598_2.png) [@Shaun17501594](https://forums.pega.com/u/Shaun17501594)\
**Post date:** [October 29, 2026, 11:47am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/3 "2026-10-29T11:47:57Z")

</div>

Hi Durai,

Thanks for sharing your approach!

Is there a specific reason you maintain your custom DX components in a GitHub repository? Is it mainly for source control and version management, or are there any other benefits, such as collaboration and deployment across environments?

Thanks,  
Shaun

---

<div class="post-metadata">

**Author:** ![JayachandraSiddipeta](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/jayachandrasiddipeta/32/23334_2.png) [@JayachandraSiddipeta](https://forums.pega.com/u/JayachandraSiddipeta)\
**Post date:** [October 31, 2026, 4:06pm UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/4 "2026-10-31T16:06:11Z")

</div>

Hello @Shaun17501594

It’s primarily for source control and versioning to ensure we have the previous version intact in git hub, in case we if to rollback to previous changes.

Regards

JC

---

<div class="post-metadata">

**Author:** ![Akhilesh.Madala](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/akhilesh.madala/32/22455_2.png) [@Akhilesh.Madala](https://forums.pega.com/u/Akhilesh.Madala)\
**Post date:** [November 2, 2026, 2:27pm UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/5 "2026-11-02T14:27:52Z")

</div>

Hi @Shaun17501594

@duraisankar explanation is correct. However, I would like to clarify a few points regarding **ruleset versioning, Standalone vs. Library mode, and GitHub version control** , based on our implementation approach.

### 1. Ruleset Management

We maintain all our custom DX components under a single ruleset, `DXComponents`, using different ruleset versions. This makes it easier to manage and track all our custom components in one ruleset.

For example:

- **DXComponents 01-01-01:** Contains `ConstellationUIGalleryLib` components.

- **DXComponents 01-01-02:** Contains our organization’s custom DX components.

We publish our organization’s custom components to version `01-01-02`.

### 2. Standalone vs. Library Mode

From Pega Constellation '25 onwards, we have two publishing approaches: **Standalone and Library mode**.

**Standalone Mode**

In Standalone mode, the component is published to the ruleset version configured in `task.config.json`.

For example:

- Initially, we publish an Email component to `DXComponents:01-01-02`.

- Later, we update the component and publish it to `DXComponents:01-01-03`.

- In our observed behavior, the component is then available under `01-01-03`, rather than retaining an independently available copy under `01-01-02`.

This is an important consideration when managing component versions.

**Library Mode**

Library mode provides a different approach to managing and versioning components.

However, one important point is that **Pega ruleset versioning and source-code versioning are different concepts**.

If we change a component’s version and modify its source code, changing the ruleset version alone does not automatically restore the previous React/TypeScript implementation.

For this, we need proper source-code version control.

### 3. Why Do We Use GitHub?

GitHub is a cloud-hosted Git repository used to store, manage, track, and collaborate on our component source code.

**Why is GitHub important?**

Suppose a developer creates multiple custom DX components and stores the source code only on their local machine.

- **Scenario 1 — System Crash:** If the developer’s laptop crashes or the data is lost, we may lose the entire source code if no backup exists.

- **Scenario 2 — Employee Leaves:** If a developer leaves the organization and the code is available only on their local machine, other team members may not have access to it.

- **Scenario 3 — Team Collaboration:** If multiple developers work on the same component, managing changes becomes difficult without a shared repository.

- **Scenario 4 — Access Control:** In a private GitHub repository, only authorized users can access the code. Repository permissions determine who can view, contribute, or modify it.

By maintaining our source code in GitHub, we ensure that the code is centrally available, version-controlled, and not dependent on any individual developer’s local machine.

It also serves as a remote backup of the code that has been committed and pushed to the repository.

**A simple example of GitHub version control:**

Suppose we develop an Email component.

**Version 1:**

- The Email component supports basic email validation.

- We commit and push the code to GitHub.

**Version 2:**

- We enhance the component by adding domain validation and error messages.

- We commit and push the updated code to GitHub.

**Version 3:**

- We introduce another enhancement, but it causes an issue.

If we want the previous working implementation, we can retrieve Version 2 from GitHub using its commit history or release tag.

We can then rebuild, test, and republish that version to the appropriate Pega ruleset.

**The main advantage is that we do not need to maintain separate local copies of every version.** GitHub maintains the committed history, allowing us to retrieve previous implementations whenever needed.

### 4. GitHub vs. Pega Ruleset Versioning

The key difference is:

- **GitHub:** Manages and maintains the history of our React/TypeScript source code, supports team collaboration, and provides centralized storage.

- **Pega Ruleset:** Manages the published component artifacts within the Pega application.

These are two different versioning mechanisms, and both are important.

### 5. Migration to Higher Environments

Once the components are published and validated in Development, we can package the required rulesets into a RAP and deploy them to higher environments using the standard Pega deployment process.

The GitHub repository remains our source-code repository, while Pega manages the published components.

We do not need to clone the GitHub repository or rebuild the components separately in every higher environment when deploying the packaged artifacts.

I hope this provides additional clarity on component publishing, ruleset management, GitHub version control, and migration to higher environments.

---

<div class="post-metadata">

**Author:** ![Shaun17501594](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/shaun17501594/32/2598_2.png) [@Shaun17501594](https://forums.pega.com/u/Shaun17501594)\
**Post date:** [November 3, 2026, 3:57am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/6 "2026-11-03T03:57:06Z")

</div>

Thanks @JayachandraSiddipeta

---

<div class="post-metadata">

**Author:** ![Shaun17501594](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/shaun17501594/32/2598_2.png) [@Shaun17501594](https://forums.pega.com/u/Shaun17501594)\
**Post date:** [November 3, 2026, 4:02am UTC](https://forums.pega.com/t/implementing-a-custom-dx-component-in-higher-environments/13891/7 "2026-11-03T04:02:20Z")

</div>

Thanks @Akhilesh.Madala
