Release management

In today’s dynamic business environment, the ability to deliver application features quickly and reliably is critical to maintaining competitive advantage. Traditional release cycles - often spanning several months or even years - are increasingly seen as a bottleneck to innovation. These prolonged cycles delay the realization of business value and hinder an organization’s ability to respond to shifting market demands. The duration from ideation to delivery and realization of value is referred to as lead time.

Release models vary
The release cadence and methodology vary significantly across organizations, influenced by factors such as:

• Development methodology (Agile, Waterfall, Hybrid)
• Regulatory and compliance requirements
• Organizational culture and tooling maturity

Regulated industries may require extensive validation and documentation, resulting in slower release cycles. Others have embraced automation and agile practices to accelerate delivery and reduce manual overhead.

Strategic importance of faster releases
Accelerating the release of application features enables organizations to:

• Deliver value to customers more frequently.
• Respond rapidly to feedback and market changes.
• Reduce risk through incremental delivery.
• Gain a competitive edge by being first to market.

To deliver value more frequently, many enterprises are adopting DevOps, which is a set of practices that unify software development (Dev), quality assurance (QA), and IT operations (Ops) to enable continuous delivery with high quality and reliability.

DevOps and agile synergy
DevOps is fundamentally about increasing collaboration and speed of delivery to reduce the time to market. DevOps complements Agile methodologies by automating and streamlining the software delivery lifecycle. While Agile emphasizes iterative development, early feedback, and customer collaboration, DevOps enhances these principles by:

• Automating build, test, and deployment processes.
• Enabling continuous integration and continuous delivery (CI/CD).
• Promoting collaboration across traditionally siloed teams.
• Reducing manual errors and improving deployment consistency.

Even teams that follow traditional delivery models can benefit from adopting DevOps practices incrementally, starting with automated testing and progressing toward full pipeline automation.

Pega Platform and Open DevOps Integration
Pega Platform™ supports DevOps through open integration with tools such as Jenkins and Microsoft Azure DevOps. This open architecture enables organizations to:

• Automate branch merging, application packaging, and deployment.
• Integrate automated testing and quality gates.
• Enforce governance and compliance through metrics and controls.
• Build scalable, repeatable, and auditable release pipelines.

These capabilities enable seamless integration with enterprise DevOps ecosystems, ensuring that Pega applications can be delivered with the same agility and rigor as other enterprise systems.

Stage 1: Development

Development begins with parallel work using branches in Pega Platform, enabling faster delivery and collaboration. Once configurations are complete, changes are merged into the main application only after automated unit tests are implemented and successfully passed, ensuring quality and stability.

Best practices in the Development stage include:

• Use branch-based development for modularity.
• Make use of built-on applications to isolate functionality.
• Maintain a single source environment as the system of record.
• Use tools such as Rule Compare for validation.
• Lock validated Rulesets to prevent unintended changes.
• Keep development environments in sync with the source.

Stage 2: Continuous integration

Continuous integration (CI) remains a foundational practice for accelerating application delivery. CI starts when developers commit and merge changes into a shared development branch. Prior to merging, automated tests in the development environment must validate that new functionality works as intended and that existing features remain unaffected.

Quick feedback from automated unit and integration tests helps developers identify and resolve issues early, reducing downstream defects. Developers should aim to merge changes frequently - ideally multiple times per day - to minimize integration conflicts and maintain a stable codebase.

Best practices include:

• Define and maintain the Rule-Admin-Product Rule to reflect the current state of the application. This Rule is essential for automated packaging using tools such as Deployment Manager or Pega CLI.
• Integrate automated unit, scenario, and API tests into the CI pipeline. Configure the pipeline to halt on test failures, to ensure that only validated code progresses.
• Use artifact repositories such as JFrog Artifactory or Azure Artifacts to store versioned application packages, enabling traceability and rollback if needed.
• Make use of branch-based pipelines to validate changes in isolation before merging to the mainline, ensuring higher code quality and stability.

Stage 3: Continuous delivery

Continuous delivery (CD) extends the benefits of continuous integration by ensuring that every validated build is always in a deployable state. The transition to CD begins with validating the application against functional and non-functional acceptance criteria using automated regression, performance, and compatibility testing.
Regression testing confirms that recent changes have not broken existing functionality. Once regression tests pass, additional layers of testing, such as load testing, cross-browser validation, and exploratory testing, can ensure that the application meets user expectations and enterprise standards.

Best practices include:

• Use containerized environments such as Docker or Kubernetes, to replicate production-like conditions for UAT and exploratory testing.
• Maintain a comprehensive suite of automated regression tests across UI, API, and integration layers using tools such as PegaUnit, Scenario Testing, and third-party frameworks.
• Store test assets in version-controlled repositories, for example, Git, to ensure traceability and collaboration.
• Implement automated rollback mechanisms in the deployment pipeline to revert to the last known good state upon test failure.
• Tag and annotate successful builds with metadata such as the version number, environment, and test results, to indicate readiness for deployment.
• Use Pega Deployment Manager, Jenkins, or Azure DevOps to automate deployment workflows, ensuring consistency and reducing manual errors.

Stage 4: Deploy

The Deploy stage focuses on the final transition of a validated application into the production environment. This phase answers the critical question: "Is the application production-ready?" Before deployment, teams must complete full validation in a preproduction environment that mirrors production conditions as closely as possible.

Version control best practices:

• Follow semantic versioning to manage application and ruleset versions: 
  • Major: Introduces breaking changes or significant new features.
  • Minor: Adds backward-compatible enhancements or incremental updates.
  • Patch: Applies bug fixes or minor updates.
• Maintain version consistency across application and rulesets to ensure traceability and rollback capability.

Best practices include:

• Define target ruleset versions and ensure they are locked before deployment.
• Use Lock and Roll to secure rulesets and promote changes to higher versions with password protection.
• Increment ruleset versions with each production deployment, unless nearing the patch version limit (for example, 99).
• Create restore points or snapshots before deployment to enable quick recovery in case of failure.
• Automate production deployments using tools like Pega Deployment Manager, Jenkins, or Azure DevOps, incorporating approval gates and rollback strategies.
• Monitor deployment outcomes and application health using Pega Predictive Diagnostic Cloud (PDC) or other observability tools.

Whether using an automated DevOps pipeline or a manual release process, certain deployment activities remain essential. The Standard Release process (as outlined in Migrating application changes) provides guidance on packaging and deploying application changes across environments.

For applications hosted on Pega Cloud®, additional governance and operational procedures apply when promoting changes to production. These include environment-specific validations, change request approvals, and coordination with Pega Cloud services.

Key considerations:

• Ensure that all deployment artifacts are version-controlled and traceable.
• Follow Pega Cloud’s Change Management guidelines to schedule and run production deployments. 
• Use Deployment Manager or Pega CLI to align with Pega Cloud’s automation and compliance standards.
• Validate all changes in a preproduction environment that mirrors production configurations.
• Maintain communication with Pega Cloud operations teams for planned changes, especially those requiring elevated access or downtime.

For detailed procedures, refer to the official documentation on Change management in Pega Cloud Services.

The end-to-end DevOps pipeline for Pega applications 

The diagram above illustrates the end-to-end DevOps pipeline for Pega applications, showing how changes move from development to production using automation and feedback loops.

1. Development
   • Developers commit changes to the system of record.
2. Continuous Integration
   • Jenkins triggers unit tests and packages the application.
   • Jenkins publishes packaged artifacts to the Artifactory Repository.
3. Continuous Delivery
   • Jenkins deploys packaged artifacts to test environments for regression, performance, and compatibility testing.
   • Jenkins promotes successful builds to staging.
4. Deployment
   • Jenkins executes post-deployment tests.
   • System Administrator imports artifacts into the production environment.

Key features:

• Automation: Jenkins orchestrates build, test, and deployment steps.
• Feedback Loops: Continuous feedback at each stage ensures early issue detection.
• Tooling: Pega Platform manages schema changes; Jenkins and Artifactory handle orchestration and artifact storage.

For more information about the DevOps pipeline, see DevOps release pipeline overview.
 

Check your knowledge with the following interaction:

---

このトピックは、下記のモジュールにも含まれています。

• Deployment design v2