Pega Platform 8.8: 7 April 2023

Pega Platform 8.
8
7 April 2023
©2023 Pegasystems Inc

Pega Platform 8.8 2
CONTENTS
Get started_____________________________________________________________________________ 4
Low-code application development and the Pega Express delivery approach. . 6
App Studio overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Building an application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Creating applications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Inviting collaborators to your application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Editing application details in App Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Creating a Microjourney for customer success. . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Application update scenarios for the Pega Express delivery approach. . . . . . 32
Adding case types to organize work. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Creating a top-level case type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Creating a primary stage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Adding a sequential process to a stage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Adding single steps to processes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Adding personas to organize users. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
More about personas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Creating personas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Associating personas with case types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Associating personas with channels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Granting personas access to channels and pages. . . . . . . . . . . . . . . . . . . . . . 60
Configuring access options for a persona. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Creating personas with developer portal access. . . . . . . . . . . . . . . . . . . . . . . 65
Providing information about application user. . . . . . . . . . . . . . . . . . . . . . . . . 66
Adding data objects to organize data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Associating data objects with case types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Implementing draft data objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Associating attachment categories with case types. . . . . . . . . . . . . . . . . . . . . 77
The Microjourney in the Pega Express delivery approach FAQ. . . . . . . . . . . . . 79
Designing and tracking Microjourneys development. . . . . . . . . . . . . . . . . . . . . . . 83

Pega Platform 8.8 3
Estimating application development. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Adopting feature-driven development. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Feature order. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Creating features. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Creating subfeatures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Reviewing application features. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Changing feature levels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Requesting feature enhancements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Creating bugs to report feature defects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Triaging a feedback item. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Associating rules with features. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Associating a feature with a work item. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Skimming features to the latest version. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Deleting a feature. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Managing application inventory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Feature-driven development tracking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Agile Workbench. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Integrating Agile Workbench with Pega Agile Studio. . . . . . . . . . . . . . . . . . . 127
Creating stories. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Creating stories in bulk. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Setting your current work item. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Changing statuses of work items. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Collaborating with development teams. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Integrating Agile Workbench with Jira in Pega Platform from 8.3.x. . . . . . . 146
Integrating Agile Workbench with Jira in Pega Platform 8.1.x to 8.2.x. . . . 149
Integrating Agile Workbench with Jira in Pega Platform 7.3.x to 7.4.x. . . . 152
Defining application behavior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Differences in naming between App Studio and Dev Studio. . . . . . . . . . . . . . 157

Pega Platform 8.8 4
Get started with Pega Platform

Plan, design, and build efficient applications by applying the principles of low-code
application development. With the low-code tools that Pega Platform™ provides, you
can create software to deliver the results that your organization needs.
By implementing the solutions that Pega Platform offers, you can create goal-oriented
applications that are easy to build, maintain, and update. Low-code application
development takes advantage of the following key principles:
Focus on customer goals
The main purpose of business applications is to help customers achieve their goals.
When you create purpose-built applications, you can focus on one goal at a time. For
example, to facilitate the work of an HR department in your organization, you can
deliver multiple applications, each focusing on a different goal, such as hiring a new
candidate or providing employee feedback. As a result, you build granular software that
you can adjust to business goals, and conveniently modify when those goals change.
Out-of-the-box functionalities
Pega Platform offers a wide variety of out-of-the-box functionalities that help you jump-
start application development, whether you are a professional or a citizen developer.
Using default solutions instead of creating your customized features saves resources,
accelerates application delivery, and facilitates a smooth update process. For example,
Pega Platform automatically creates user interfaces based on low-code configurations
that you provide.
IT and business collaboration
Low-code tools help IT and business cooperate, to define business goals and create
digital solutions to reach those goals. Pega Platform offers visualization tools that you
can use to create graphic representations of business processes, so that the design and

Pega Platform 8.8 5
development phases include all stakeholders. Additionally, creating granular

applications in Pega Platform is suited to citizen developers without highly technical
knowledge, as low-code tools are based on a user-friendly and intuitive interface. As a
result, even users whose background is more business-oriented than technical can
successfully deliver software that meets their needs.
You can enhance business and IT collaboration by using out-of-the-box App Factory
functionality. App Factory is an application platform that you can use to capture shared
objectives with stakeholders, accelerate application development, and scale quickly and
seamlessly within your organization. For more information, see Manage enterprise
apps with App Factory and the Pega Low-Code App Factory learning module on Pega
Academy.
Reuse
Most of the objects that you create in Pega Platform are reusable, and if your business
scenarios vary, you can conveniently edit the elements required for different situations,
without creating entirely new objects. For example, you can create a process of
collecting personal information from customers, and then reuse this process in multiple
scenarios, such as a credit card dispute and a loan request, as shown in the following
figure:

Pega Platform 8.8 6
Reusing resources
As a result, your application development is efficient, and you can save resources such
as time and money.
Agile development
The low-code Pega Platform environment promotes agility and iterative progress so
that you can flexibly adjust your software to dynamically changing business
circumstances. Start your application development by identifying a small amount of
scope that you can deliver into production quickly but yielding high value. Pega
Platform refers to a minimum scope that is required for production as minimum
lovable product (MLP). Then edit and expand your software with features that best suit
your current business requirements. By implementing this approach, you can deliver
the first MLP relatively quickly, and then continuously develop and improve your
application.
To learn more about low-code application development and to start building

applications, explore the following articles:
• Low-code application development and the Pega Express delivery approach
• Building an application
• Creating a Microjourney for customer success
• Designing and tracking Microjourneys development
• Defining application behavior

Pega Platform 8.8 7
Low-code application development and the

Pega Express delivery approach
Start delivering granular applications that precisely meet your business requirements
by applying low-code application development. After you familiarize yourself with low-
code tools and processes, you can quickly start creating software, and as a result,
achieve your business objectives.
The Pega Express delivery approach
Pega Platform™ supports an iterative and agile approach to building applications that is
called Pega Express™ delivery approach. In the Pega Express delivery approach,
achieving a main business objective is presented as a journey that you can divide into
smaller parts – Microjourneys®. When you focus on one Microjourney at a time, you
ensure that you can deliver software that helps customers achieve their goals in the
most efficient and suitable way. Then, you can iteratively expand and update your
software to adjust to changing business circumstances.
Before you start creating applications to complete your Microjourneys, answer the
following questions:
What is the purpose of my application?
The goal that you want to achieve dictates the actions and processes that you need to
include in your Microjourneys. You define actions in your Microjourneys by building
case types that are visual, reusable, and granular templates of your business processes.
During the life cycle of your application, you can expand and edit initial versions of your
case types to better fit your business goal. For greater flexibility, you can define which
actions you want to start conditionally or optionally, under only the circumstances that
you specify. As a result, case types that you build are more flexible and adjust better to
various scenarios. Because case types and their elements are reusable, identifying
repeating actions in different Microjourneys saves time and other resources during
application development.

Pega Platform 8.8 8
With Pega Platform, you can focus on the business objectives and create flexible
software that exactly suits your requirements, instead of strictly adhering to fixed
solutions that over time might stop fulfilling their initial purpose. You can respond in an
agile way when the path to the objective needs changing, and even when the objective
itself changes.
For example:
When you design an application for an HR department, think about the goals
that the software needs to meet. Hiring a job candidate and reviewing expenses
require different sets of actions, and breaking them into separate Microjourneys
might help you focus on delivering solutions that exactly fulfill each goal. The
following table lists sample actions that each Microjourney might include:
Hiring a job candidate Reviewing expenses
Collecting personal details Collecting personal details
Reviewing work experience Collecting receipts
Conducting a job interview Reviewing receipts
Approving or rejecting a candidate Approving or rejecting a request
Optional: Running a background check Optional: Applying currency rates
For each Microjourney, identifying repeatable elements and optional actions can
save development resources when you build the software.
Who is my application for and how do they need to use it?
Although an application might include a high level of automation, in most cases, it also
involves interactions with end users. In Microjourneys and in the Pega Express delivery
approach, groups of users correspond with personas. Each persona has a unique set of
skills, objectives, tasks, behaviors, and business roles, and might interact with an
application in a different way. For example, a set of available actions might be different
for an HR worker who reviews a job candidate, than for a hiring manager who either

Pega Platform 8.8 9
approves or rejects the candidate, because a set of skills and business requirements is
different for each of these users. Personas help you visualize those groups of users so
that stakeholders and the development team can better understand who uses the
application. By understanding the specific needs of users you can better tailor the
application process and user experience to each persona.
Additionally, consider the different channels that users might employ to interact with
your application, such as a web portal or a mobile application, as well as the different
devices that users might work with, such as mobile phones and tablets. Define the
elements that particular participants need to access so that you can avoid exposing the
users of your application to irrelevant content. Finally, decide whether your application
users need both online and offline access to perform their work.
For example:
Consider a scenario in which you need to create an application for the following
types of personas. Each persona uses a different channel and performs different
actions in an application:
Persona Channel Actions
Job candidate Mobile app

• completing forms
• uploading
attachments
HR worker HR portal
• verifying forms
• opening certain
attachments
Hiring manager Manager portal

• opening all
attachments

Pega Platform 8.8 10
Persona Channel Actions
• accepting and
rejecting candidates
By listing personas with relevant channels and actions, you can tailor your
application to meet the needs of different types of users.
An important aspect of application development is accessibility, so that users who

experience your application in a different way can have a successful Microjourney.
Consider the following scenarios:
• A part-time customer service representative (CSR) at a hotel chain has reduced

vision and a slight hand tremor. The CSR has difficulties reading small text and
clicking on small links and form elements. The CSR relies on enlarging text in a
browser, but often text and pages do not format correctly, which requires a lot of
scrolling. The CSR prefers using a keyboard to a mouse due to the hand tremor.
• A visually impaired college graduate uses screen readers while working at a
government office to process building permits. The graduate has difficulties when
fields on forms are not labeled, which results in mistakes in processing and filling
forms, and requires the graduate to work longer hours. Also, the graduate misses
some information that only images and graphics include.
• A bank clerk helps customers set up new accounts and tries to sell related
products as he gets a partial commission. His co-workers are unaware of his
difficulty distinguishing red and green. He has difficulties when reviewing his
progress in an application that uses colors for indicating opposite meanings like
good and bad as they all look brown to him.
The following figure shows a pie chart that an application displays with red and
green, and the image how the bank clerk from the example might perceive the
chart:

Different perceptions of colors
When you design your application, take into consideration unique scenarios and
experiences that users might have, so that you can create an inclusive and flexible
Microjourney. For more information, see Configuring an accessible UI.
How does my application source and store data?
Data is an essential element in work processing. When you design your Microjourney,
think about the different data sources that you need to successfully complete your
business process. Pega Platform offers multiple ways of sourcing data to meet your
unique business needs. You can create an application that collects information directly
from end users, reuses data that already exists in the system, or that connects to
external databases to take advantage of third-party resources. As a result, you
maximize efficiency during both application development and actual processing.
For example:
During a hiring process, a job candidate provides personal information by

completing a form in a mobile application. The candidate can also attach any
relevant documents, such as scanned university diplomas. An HR worker who
works on the process sources the work experience of the candidate from an

external database. The personal details that the candidate provides are
applicable for other processes, such as preparing an offer for the candidate, or
preparing onboarding.
Reusing data in a Microjourney
An example of a Microjourney
Consider a scenario in which a customer creates a loan request. The objective of this
Microjourney is to review the request from the customer. The business process
requires the following actions:
• Collecting information from a customer

• Reviewing and evaluating collected data
• Rejecting or approving the loan request

When you know what actions are part of the business process, you can decide what
personas and channels the process involves, for example:
• A customer who creates a request through a web portal

• A worker who reviews and processes collected data through a mobile app for
workers
• A manager who approves or rejects the request through a mobile app for
managers
You can also define what data the business process needs to reach resolution:
• Personal details that the customer provides

• Banking history of the customer that an application sources from an internal
database
• Credit score of the customer that an application sources from an external
database
The following figure summarizes the Microjourney of reviewing a loan request:

Microjourney in the Pega Express delivery approach
Designing Microjourneys
Pega Platform offers a low-code tool that you can use to conveniently discuss and
design your Microjourney in cooperation with other stakeholders. By designing your
Microjourney in App Studio, you document the business process workflow and
requirements, both for IT and non-IT stakeholders. For more information, see Designing
and tracking Microjourneys development and Creating a Microjourney for customer
success.
For example:
The following figure shows a sample Microjourney that focuses on reviewing a

job candidate, with the actions that users perform, the types of users
represented by personas, and the data that the Microjourney requires.

A Microjourney in App Studio
For relevant learning materials, see the following modules on Pega Academy:
• Microjourney defined
• Defining a customer Microjourney
For more information about Microjourneys, see Pega Express delivery approach.

• App Studio overview
App Studio overview

Turn your application development into a no-code, user-friendly experience by working
in App Studio. In this authoring environment, you can configure the main elements of
your applications that include templates for your business processes, personas that are
involved in the processes, interaction channels, and data.
App Studio purpose
App Studio provides you with tools to develop your applications in a way that is
convenient and understandable for a citizen developer with little or no knowledge of
any programming language. In App Studio, you can prepare the following application
elements:
• reusable templates for your business processes that Pega Platform refers to as
case types, and that users complete at run time to reach a successful outcome.
For more information, see Adding case types to organize work.
• personas that you create to visualize groups of users that interact with your
application, such as customers, workers, or managers. You can define access
settings for each group so that users view and process only relevant information.
For more information, see Adding personas to organize users.
• data objects to ensure that the users have information required to resolve cases.
For more information, see Adding data objects to organize data.
The approach of building your business processes on case types, personas, and data
objects is a part of the Pega Express delivery approach, the method of delivering
projects in a no-code and user-oriented way. In the Pega Express delivery approach,
you use App Studio to model your business processes by creating case types, personas,

and data objects. A single business process that results in an expected outcome is a
Microjourney.
App Studio roles
App Studio targets business analysts, citizen application developers, front-end

developers, and data engineers. For improved communication between developers and
stakeholders, App Studio supports real-time UI design, so that any person that is
involved in a business process can contribute to application planning and development,
the approach that helps achieve the best effects while providing IT solutions for
business.
App Studio tools
In App Studio, you can find multiple tools for developing and maintaining applications.
On the Overview page, you can find basic information about your application, for
example, case types and personas that your application includes. By exploring work
areas, you can quickly view and create the main parts of your application, such as case
types, personas, channels, and UI elements. Each work area offers no-code solutions
that you can use to model your business processes in the most efficient way. The
following video shows what you can find in each work area:
To see the results of your work at run time, preview an application display on a device,
and launch portals associated with your application. While in a preview, you can turn on
the design mode to conveniently make any necessary adjustments by interacting with
UI elements. Apart from building applications, in App Studio you can work with tools to
collaborate with other developers and track your development work, for example, by
posting messages and toggling Agile Workbench. To ensure that you maintain a good
health and quality of your application, explore options that you can use to monitor and
maintain your application performance. The tools include Clipboard, Tracer, and
Accessibility Inspector.

App Studio access
To access App Studio, you associate the pxExpress portal with your access group. For
more information, see Granting portal access to an access group.
From App Studio you can switch to another workspace any time and change the tools
and features that are available in your work environment. For more information, see
Changing your workspace.
For relevant learning materials, see an App Studio module on Pega Academy.
What to do next: Start planning and implementing your Microjourney. See Creating a
Microjourney for customer success
Related concepts

• The Microjourney in the Pega Express delivery approach FAQ
• Dev Studio overview
• Admin Studio overview
• Prediction Studio overview
• Agile Workbench
Related information
• Workspaces
Building an application
Create scalable and flexible applications by employing low-code tools that Pega
Platform™ offers. You can create your first application in just a few clicks, giving you a
starting point to develop your application.
When you build your application, you can benefit from the following factors:

Variety of UI experiences
When you create an application from scratch, you can select the type of UI that you
want to apply, so that you provide the experience that best meets the current needs of
both end users and application developers. The following figure shows a selection of
user interface types, based on their usage and rendering method.
Types of user interfaces
For more information about different types of UI, see Traditional UI architecture and
Constellation architecture.

Reusing applications
After you create an application, you can use it as a template to build other applications.
By implementing this approach, you can quickly reuse all the assets that your base
application includes, and as a result, deliver software faster and save other resources,
such as money. You can then tailor your new application to meet your new or detailed
business objectives.
For example:
You can create an application to review mortgage requests by building on a base

application to review general financial requests. You can then reuse assets, such
as case types and data, that the base application includes, and change only
those components that are unique for reviewing mortgage requests, as shown in
the following figure:
Building an application on another application
Immediate teamwork
You can immediately invite collaborators to your new application so that your team can
quickly start creating new software. For better work management, when you invite a

collaborator, you can also assign them an appropriate role in your application, such as
an administrator.
Start your application development by performing the following actions:
• Creating applications
• Inviting collaborators to your application
• Editing application details in App Studio
Creating applications
Start developing your projects conveniently and intuitively by building your application
on an application template. When you create an application on a template, you save
time because you reuse key elements of an existing application, such as case types or
data types.You can choose a default application template that Pega Platform provides
or reuse one of your existing applications as a template. For example, you can create an
application to review mortgage requests, and then supply the application with
necessary case types, data types, and other elements. Then, you can build an
application to review loan requests by using the application to review mortgage
requests as a template. As a result, all assets from the application to review mortgage
requests are automatically available in the new application to review loan requests.
Before you begin:
• If you want to build an application in App Studio, ensure that you have an
access group based on SysAdm4 role or an pxCreateNewApplication privilege,
and that the production level is equal or lower than 4. For more
information, see Learning about access groups, Creating a privilege, and
Specifying the production level.
• If you plan to use a custom application template, configure the template for
reuse. For more information, see Configuring applications for reuse.

Note: If you build your application on a custom template, fields to

complete and the creation process might vary.
• If you plan to collaborate with users without an operator ID, configure the
Default email account. For more information, see Configuring outbound
email.
For relevant training materials, see the Creating Pega Platform applications module on
Pega Academy.
1. Navigate to the New Application wizard:

• To build an application in App Studio, in the header of App Studio, click the
name of your application, and then click New Application, as shown in the
following figure:
Creating an application in App Studio
• To build an application in Dev Studio, in the header of Dev Studio, click the
name of your application, and then click New Application.
2. Choose a type of application to create:
• To build an application that joins traditional UI authoring with a unique
Theme Cosmos run-time experience, click Build from scratch, and then click
Theme Cosmos.

With a Theme Cosmos authoring experience you can save time by

implementing a vast selection of auto-generated functionalities. You can also
focus on low-code tools and solutions as Theme Cosmos is primarily
designed for App Studio. For more information, see Traditional UI
architecture.
• To build an application that uses Constellation UI authoring and run-time

experience, and is also client-side rendered, click Build from scratch, and
then select Constellation.
Constellation is an innovative way of designing applications that currently

supports a limited range of case management functionalities. For more
information, see Constellation architecture.
• To build your application on a custom application template, hover over the

application name, click Continue, and then click Build with application
template name.
For more information, see the implementation guide for your application.
• To search for an application template, click Search all types.

3. If you build your application on a custom template, and you want to reuse
resources from the application, such as case types or data types, import the
resources to your new application:
a. In the Select case types section, select the check box next to each relevant
case type.
b. Click Continue.
c. In the Select data types section, select the check box next to each relevant
data type.
d. Click Continue.
4. In the Name your application field, enter a unique name for your application.
5. Optional: To configure a custom class structure, organization, or select the base
language for your application, click Advanced configuration.

For more information about the settings that you can change, see Configuring
advanced settings for new applications.
6. Click Create application.
7. Optional: To develop your application more quickly, in the Optionally, add users
section, create a team:
a. In the text field, press the Down arrow key, and then select a user name or
an email address.
If you enter an email address that is new in the system, the system creates a
new user.
b. Control which type of access the user has to your application by selecting a
role in the list.
c. Click Add.
CAUTION: If an email account error occurs when you add a user,

take note of the user ID and generated password, because the user
may not receive these credentials in an email.
8. Click Go to app.
• Constellation architecture
• Configuring advanced application settings
• Styling your application with design systems
• Configuring applications for reuse
• App Studio overview
Inviting collaborators to your application

Enhance your application and begin processing your business cases by inviting
collaborators with different skills and roles.
When you invite collaborators, you define the type of access that you grant to the users
of your application. Your application illustrates different user and access types by

personas. You can select from personas that reflect run-time users, and developer roles
that correspond with design-time users. For example, you can invite members of a
development team and associate them with developer roles, so that the team can start
working on your application. You can also invite run-time users to process work in your
application and, for example, associate them with a customer service representative
(CSR) persona.
Before you begin:
• Populate the list of available personas. For more information, see Creating
personas.
Administrator and author personas are available by default.
• Define the types of access that different users of your application can have.
For more information, see Granting personas access to channels and
pages.
1. In the navigation pane of App Studio, click Users, and then click User
management.
2. On the People tab, in the working area, click Invite people to your application.
3. In the Add users to application window, in the autocomplete field, press the
Down arrow key, and then select a user name or email address.
Result:
If you enter an email address that does not exist as an operator in the
system, the system creates a new user.
4. In the list of personas, define the type of access for the user of your application,
by selecting a role:
• To invite run-time users, select an option from the Personas section of the
list.

• To invite design-time users, select an option from the Developer roles

section of the list.
For example:
Associate the user with a run-time CSR persona, as shown in the following
figure:
Selecting a persona for a user
5. Click Add.
6. Send an email with an invitation to the user by clicking Send invitation.
7. To invite more users, repeat steps 3 through 6.
8. Close the Add users to application dialog box.

What to do next:
Analyze what data your case requires to reach a resolution by defining data
objects. See Adding data objects to organize data.

• Adding personas to organize users
• Creating personas
• Creating a team
• Creating applications
Editing application details in App Studio

Provide up-to-date information about your application that you can adjust when your
business requirements change by editing application details. As a result, you
communicate accurate metadata about your projects and respond flexibly to
dynamically changing business conditions.For example, if you want to extend your Loan
reviews application to include mortgage reviews, you can communicate this change by
editing an application's name and business objectives.
1. In the navigation pane of App Studio, click Overview.

2. In the Overview workspace, click Edit next to your application name, as in the
following figure:

A button to edit application details
3. In the Application details dialog box, update the information about your project:
• To rename your application, in the Application name field, enter a new value.
• To change the URL of your application, in the Application URL field, enter a
new value.
You can only change a part that reflects the application name.
• To provide additional information, in the Description text box, enter more

details about your application.
• To explain the purpose of your application, in the Business objectives field,
describe what users can achieve by using the application.
You can add multiple business objectives by clicking Add objective.
4. Click Submit.
For example:
The following figure presents a sample way of completing application details:

Providing application details
Related tasks
• Documenting your application
Creating a Microjourney for customer

success
Help your customers reach a successful resolution in their business processes by
applying the Pega Express delivery approach while working on implementation projects
through journeys and Microjourneys®. When you focus on one journey at a time, you

not only improve how you address the specific needs of your customers, but also reach
results more rapidly.
A journey and a Microjourney
A journey is the series of interactions between a customer and an organization that

occur as the customer pursues a specific goal, such as hiring a job candidate. To deliver
results of the highest quality, divide your journey into smaller units that you can adjust
to your customers' requirements. A Microjourney represents a unit of work that results
in a particular outcome, for example, reviewing a job application. For improved
planning and development of your Microjourney, Pega Platform employs the Pega
Express delivery approach that enhances the experience of building your applications
and delivering your projects. A Microjourney has the following elements as its
foundation:
• Case types that visualize the path of your business processes

• Personas that represent the people that are involved in your processes and the
channels that they use to interact with a case
• Data that your processes require to reach a resolution

Elements of a Microjourney
Efficient Microjourney planning
When you plan your Microjourney, you create draft relationships between cases,
personas, and data objects. This planning phase helps your development team
estimate the time and effort that they need to turn these drafts into permanent objects,
so that you can build your application and deliver your projects faster. In addition, by
visualizing all of the key aspects of your case within a single view, you improve how you
understand and communicate the various aspects of development that your
Microjourney involves.
For more detailed planning of your application development, you can specify the
releases with which you plan to implement specific elements of your Microjourney. For
example, in a hiring process, you can define a job candidate persona that in the first
release of your application can only fill in a questionnaire that collects personal details.
As you further enhance your application, you can indicate that in the second release
the job candidate will also be able to upload scans of required documents.
Releases of a job candidate persona

The following figure presents creating a draft relationship between a case type and a
persona:
For relevant learning materials, see a Defining customer Microjourney and Pega
Express delivery modules on Pega Academy.
What to do next: Learn how to plan and implement your Microjourney through the
following articles:
• Application update scenarios for the Pega Express delivery approach
• Adding case types to organize work
• Adding data objects to organize data
• The Microjourney in the Pega Express delivery approach FAQ
• Adopting feature-driven development

• Designing and tracking Microjourneys development
Application update scenarios for the Pega Express

delivery approach
To start planning your Microjourney® in a user-friendly, transparent, and holistic way,
first update your application. As a result, you can visualize the key elements of your
cases – case types, personas, and data – on one screen, so that you can improve your
understanding of the needs of your customers.
Note: You only need to update your existing applications that you created in
Pega Platform 8.3 or earlier. All new applications that you create in Pega
Platform 8.4 and later support the Pega Express delivery approach by default.

The update proceeds in the following order:
1. When you open your existing application in App Studio, a prompt to update your
application is displayed.
2. After you accept an update, your application creates rules corresponding to data
objects and personas. Your application uses an unlocked ruleset or a branch to
store the rules.
By default, your application uses logic to choose the best unlocked ruleset. If you
want to specify a ruleset to store the new rules, specialize the pySetUpgradeRuleSet
data transform. For more information, see Data transforms.
3. When the update is complete, you need to merge the new personas and data
objects rules.
For more information about merging rulesets, see About the Ruleset Maintenance
wizard.
For more information about merging branches, see Merging branches into target
rulesets.
If your application includes built-on applications, update the built-on applications first.
If you update your built-on applications first, when you update your current application,
it only references the data objects from your built-on applications.
By updating your current application first, it creates the data objects that it uses from
the built-on applications. If you update your built-on applications later, it duplicates the
data objects. As a result, when you start by updating your built-on applications, you
save time and resources.
Update without built-on applications
During the update, your application performs the following tasks:
• Creates new data objects that correspond to all the data types that are present in
your application.

• Creates personas that correspond to all the access groups in your application that
do not have access to Dev Studio, App Studio, Admin Studio, or Prediction Studio.
• Matches releases with color-coded symbols, if your application includes releases.
If your application does not include any releases, it creates new releases.
Update with built-on applications
During the update, your application performs the following tasks:
• References existing data objects from the built-on applications to avoid

duplicating items, if you update the built-on applications first.
• Creates personas that correspond to all the access groups in your current
application and built-on applications that do not have access to Dev Studio, App
Studio, Admin Studio, or Prediction Studio.
• Matches releases with color-coded symbols, if your current application or built-on
applications include releases. If your application does not include any releases, it
creates new releases.
What to do next: After you update your application, start planning your Microjourney.
See Adding case types to organize work.
For relevant training materials, see the Defining a customer Microjourney module on
Pega Academy.

• Data modeling
Adding case types to organize work

To manage your Microjourney® efficiently, automate and visualize your business
processes by creating case types. When you implement case types, you organize your
work into consistent and logical phases, collect and control the data that your process
requires, and audit information to ensure that your outcomes are of top quality.

A case type is a reusable template that represents a business process. For better
understanding of your customers' needs, design your application by describing the
stages within a case type, then define the steps or processes that happen in each stage
when the case workers process an actual case. This provides an easy way to capture
objectives in a single view that all case participants, from application designers to
executives and end users, can use to understand how a particular case type works and
progresses. Cases can continue to change throughout their life cycle due to various
internal and external events. Depending on the context of the case, different case
workers can work to resolve individual tasks, processes, and stages. This flexibility helps
you achieve your goals in the most effective way.
The following figure shows a sample case type which aim is to first review and then
approve or reject a job candidate. The case type includes five stages, with at least one
process in each stage. The case type includes both user actions, such as collecting
information, and automations, such as sending an automated email to a candidate.

Sample case type
Maximize efficiency during the case life cycle by implementing the following features:
• To support and facilitate resolution of more complex cases, create a hierarchy of

parent-child cases. Organize smaller processes into child cases to resolve for a
parent case to reach its end.
For more information, see TBD.
• To ensure that the appropriate case worker receives a task, define routing for
assignments. You can assign tasks to a work queue, worklist, or a specific case
worker, or you can define routing logic that automatically chooses the correct
assignee at run time.
For more information, see Assigning tasks to users.
• To support timely case resolution, define service-level agreements (SLAs) for a

case type or specific stages or tasks within a case. Enrich the SLAs and make them
more effective by adding escalation actions.
For more information, see Completing work on time.
• To allow case workers to collect information and feedback from end users, design
surveys. Supplement the surveys with multiple question formats, such as text
boxes, sliders, or radio button matrices.
For more information, see Designing questionnaires.
What to do next: Add case types to your Microjourney by completing the following
tasks:
• Creating a top-level case type
• Creating a primary stage

• Adding a sequential process to a stage
• Adding single steps to processes
Creating a top-level case type

Improve work processing in your application by creating top-level case types that
visualize business processes. When you visualize a business process, you can
conveniently divide the process into phases, and then track and manage work with
greater ease.For example, you can create a top-level case type that represents a hiring
process, and then reuse the type every time when you want to process a job application
from a new candidate.
1. In the navigation pane of Dev Studio, click Case types.

2. In the navigation pane of App Studio, click Case types.
3. Click Add a case type.
4. In the header of the Case types section, click New.
5. In the Name field, enter a name for the case type.
6. In the Case type name field, enter a name for the case type.
7. In the Type list, select Standard.
8. Optional: To reuse assets from another case type, click Advanced, and then in the
Reuse assets from list, select a case type.
9. Optional: To change the inheritance model for this case type, expand the
Advanced Settings section, update the Derives from (Directed) and Derives from
(Pattern) inheritance settings, and then provide rulesets and ruleset versions.
The inheritance model defines classes from which your case type can inherit data.
For more information, see Understanding class hierarchy and inheritance.
10. Click Submit.
11. Click Next.

Result:
Your new case type includes a default Create stage with a Create process, as
shown in the first figure. The second figure shows the same case type already
populated with stages and processes.
Newly created case type

Populated case type
What to do next:
• Divide work into phases by adding stages to your case type. For more
information, see Creating a primary stage.
• Create child case types that represent dependencies that you resolve
before the top-level case type can reach the resolution. For more
information, see Creating a child case type.
• The Create stage

• Case life cycle elements
• Creating a data model from a spreadsheet
Creating a primary stage

Represent main phases of your business process by creating primary stages in a case
life cycle. By creating stages, you can ensure that your work is divided into logical
phases, so that you can track and resolve the tasks more conveniently.For example, for

a Review job application case type, you can create stages, such as Submission,
Application review, Decision, and Job offer.
Before you begin:
Define a case type. For more information, see Creating a top-level case type.
When you create a new case type, the system automatically creates the first stage,
which is the Create stage. For more information, see The Create stage.
1. In the navigation pane of App Studio, click Case types, and then click the case type
that you want to open.
2. On the Workflow tab, click Life cycle.
3. In the Case life cycle section, click Stage, and then enter a unique name in the text
box.
By default, the system creates a stage for each case life cycle that you define.
4. In the Stage property pane, on the General tab, define the transition after this
stage is complete:
• To move to the next stage, select Automatically move to next stage.
• To let the customer service representative decide which stage the case
enters, select Wait for a user action.
• To close the case, select Resolve the case, and then define the resolution
status and options.
5. Click Save.
Result:
The following figure shows a case type with four empty stages. A green bar
marks the Create stage, and a red bar marks the resolution stage:

Stages in a case type
At run time, a breadcrumb navigation of a case displays names that you

associate with the stages, as shown in the following figure:
Case breadcrumb navigation
What to do next:
Organize work within stages by adding processes. For more information, see
Processes in a case life cycle.
• Case life cycle elements

• Creating an alternate stage
• Processes in a case life cycle
Adding a sequential process to a stage

Control the order of events in a case by adding a sequential process to a stage. A
sequential process orders related actions that lead to the resolution of a case.
For example, if your business case is to review a job application, you can create a
sequential process that includes the following tasks:

• Prepare interview questions

• Conduct the interview
• Prepare the candidate's assessment
Before you begin:
Add stages to your case type. See Creating a primary stage.
3. In the Case life cycle section, hover over a stage, and then select a process to add:
• To add a new process, click More > Add process > New process.
• To reuse an existing process, click More > Add process > Process name.
4. In a new text field, replace the default process label with a descriptive name.
5. Optional: To change the run-time order of a process, drag the process to a
different position in the stage.
6. Click Save.
Result:
At run time, the process starts when all steps in the previous process are
complete.
What to do next:
• Provide meaningful tasks for your process by adding steps. For more
information, see Adding single steps to processes.
• Make your process applicable only to a certain scenarios by defining
conditions to start a process. For more information, see Conditionally
starting a process.

• Conditionally starting a process

• Creating a stand-alone process
Adding single steps to processes

Model your business process with basic tasks that users or automations resolve, by
adding steps to your case life cycle. When users complete steps, your case moves closer
to its resolution and to achieving your business goal.
Before you begin:
Add processes to stages in your case type. See Adding a sequential process to a
stage.
3. In a process, click Step, and then select a step type that you want to add.
• To add a step that displays a form that users complete to provide data, click
Collect information.
• To add an approval step, click Approve/Reject.
Adding an approval step automatically creates an alternate stage in a case

life cycle. For more information, see Creating an alternate stage.
• To add a step that creates multiple screens with which users interact to
provide data, click Multi-step form.
For more information, see Adding a multistep form to a stage.
• To add an existing process as a single step, click More > Processes, and then
select the process that you want to use.

• To add a step that requires human interaction, such as manually adjusting a

service-level agreement, click More > User action, and then select an action
that you want to use.
• To add an automation that an application performs, click More >
Automations, and then select an automation that you want to use.
For more information, see Adding an automated step to a process.
4. Optional: To provide a unique name for the step, in the text field, replace the
default step label with a descriptive name.
5. Click Save.
For example:
The following figure shows a stage in a case type of reviewing a job candidate.
The stage includes one process that has three steps of different kinds: an
automation that pauses the process until a user conducts a job interview, a step
to collect information, and an approval step.

Sample steps
What to do next:
Start planning your case type by associating personas with your case type. For
more information, see Adding personas to organize users.
• Adding an automated step to a process
Adding personas to organize users

You can manage users more intuitively through personas, which store comprehensive
information about the roles and access rights of all of the stakeholders in a process.
Personas are a design tool that helps you group users according to the responsibilities
that they assume within a process, the cases on which they work, and the channels that

they can access. This grouping provides for a more granular level of control over the
user experience, from defining which stages of a case belong to which type of user, to
customizing the interface to include only the information that a specific role requires.
You can create as many personas as you like, and use them as reference for building
access groups in your application.
For example, when designing a job application review case, you create a job candidate
persona and an HR worker persona. The candidate uses an elegant, consumer-grade
mobile app interface, while the HR worker relies on a more utilitarian, task-oriented
web portal with back-office functionalities. During the design process, you decide that
both personas should have access to the first stage of the case, so that both the
candidate and the HR worker can perform relevant actions from their respective
interfaces. However, only HR workers should be allowed to view, advance, and resolve
the case, so you assign the rest of the case to the HR worker persona. The following
figure shows the job application review case with job candidate and HR worker
personas, assigned to relevant stages:

Personas in a case type
By keeping your personas, access groups, and interfaces parallel, you make the case
flow more transparent and adaptable to future changes.
The following figure shows a matrix in App Studio that you can conveniently use to
define portals and pages that each persona in your application can access:

Access matrix
What to do next: Create and implement personas in your Microjourney® by

completing the following tasks:
• More about personas
• Creating personas
• Associating personas with case types
• Associating personas with channels
• Granting personas access to channels and pages
• Configuring access options for a persona
• Creating personas with developer portal access
• Providing information about application user
• Understanding personas and access management

• Inviting users to an application
More about personas

A persona defines a typical user or group of users that use a product or service in a
particular way. Personas define internal and external stakeholders who use the system
in different ways based on their role and desired business outcome. The purpose of
personas is to create consistent and realistic representations of your key system users
to better understand their needs, expectations, and behaviors. This approach helps you
better design products and services that enable the right outcomes and experiences.
Use qualitative and quantitative data while you create personas. The more realistic the
personas, the more effective they are in helping in the design and development
process.
Effective personas have the following characteristics:
• Represent a major user group for your application.

• Express and focus on the major needs and expectations of user groups.
• Give a clear picture of the users' expectations and how they are likely to engage
with the application.
• Aid in uncovering universal features and functionality.
• Describe real people with backgrounds, goals, and values.
• Consider internal and external systems that regularly interact with your
application.
Why personas are important
Personas provide meaningful insights that you can use to assess your design and
development. You build personas so that you can ask the right questions and base your
answers on the real understanding of your users. Personas are incredibly useful when
you do not have easy access to real users because they act as user stand-ins, helping to
guide your decisions about functionality and design. Questions like "How would Ross
use this feature?" or "Would Frances even be interested in this?" can start great

conversations within your team, getting you to think the way that your users actually
interpret and interact with applications to achieve their goals. In short, personas are
one of a range of modeling techniques that help us build apps that help users complete
their work effectively.
Benefits of personas
Personas help you build your decisions about application features, functions, and
components, by adding a layer of real-world consideration. They also offer a quick and
inexpensive way to test and prioritize those elements of your application throughout
the development process. In addition, personas can aid the following groups:
• Stakeholders and leaders - to evaluate new application feature ideas.

• Designers - to create the overall look and feel of the application.
• All stakeholders - to understand what information and functionality is relevant
and necessary to a specific persona’s role.
• System engineers and developers - to decide which approaches to pursue based
on user behaviors.
• All stakeholders - to make applications consistent and responsive to the specific
persona.
Elements of a persona
A persona generally includes the following key pieces of information:
• Fictional name
• Job title and major responsibility
• Demographics, such as age, education, and other relevant information
• Goals and tasks the persona tries to complete using the applications
• Physical, social, and technological environment
• Quote that sums up what matters most to the persona as it relates to your
application
• Casual picture representing that user group

General guidance
• Do not guess what personas your application requires. Instead, discover them as
a part of your user research, which then provides information for your user story
development.
• Write specific personas, designing each persona for a single type of user. Instead
of forcing a user to adjust, focus on developing flexible software that adjusts to
the user.
• Create a primary persona to represent someone who must be satisfied but who
cannot be satisfied by a user interface that is designed for another persona.
• Learn the goals of each persona so that you can decide what your system needs
and does not need to do, and what data is displayed.
• Do not identify more than three primary personas. If your application seems to
require more personas, your scope might be too broad.
• Define a finite number of personas. Your goal is to design the system for specified
users.
How personas are used in design
Personas are a design tool that helps you group users according to the responsibilities
that they assume within a process, the cases on which they work, and the channels that
they can access. This grouping provides for a more granular level of control over the
user experience, from defining which stages of a case belong to which type of user, to
customizing the interface to include only the information that a specific role requires.
You can create as many personas as you like and use them as reference for building
access groups in your application. However, think about your scope as you develop
personas for a specific feature. Ensure that the size of components, UI elements, and
action areas target the correct device size and persona. For example, because Pega
Platform allows multiple app views in a single application, you can easily create a
simplified mobile and chatbot view for end users and a back-office view for employees,
each using the same data and processes but displayed in different views based on a
persona's needs.

Examples of personas
When you design a credit card dispute case, you create a customer persona and a
customer service representative (CSR) persona. The customer uses an elegant,
consumer-grade mobile app interface, while the CSR relies on a more utilitarian, task-
oriented web portal with back-office functionalities. During the design process, you
decide that both personas need access to the first stage of the case, so that both the
customer and the CSR can initiate a dispute from their respective interfaces. However,
only CSR users should be able to view, advance, and resolve the dispute, so you assign
the rest of the case to the CSR persona.
After you map your case, you can adjust persona settings to include default interfaces,
and create relevant access roles for your application in Dev Studio. By keeping your
personas, access groups, and interfaces parallel, you make the case flow more
transparent and adaptable to future changes.
The following table illustrates the configuration of personas in a credit card dispute:
Persona Channel Interface Can Can Access

type initialize resolve group
dispute dispute
Customer Mobile Customer Yes No Customer
CSR Web Case Yes Yes Case

worker worker
Related concepts

Creating personas
For enhanced planning and understanding of your business processes, add participants
to your Microjourney® by creating personas. When you create personas, you group

users by their responsibilities in a process, the channels that they can access, and the
cases on which they work.
For example, for a hiring process, you can create personas that represent a job
candidate, an HR worker, and a manager.
When you create personas, you define metadata that represents the users of your
application. By visualizing users, you can easily plan and communicate the
development of your application.
Before you begin:
Define your case type, and then populate the case life cycle with stages,
processes, and steps. See Adding case types to organize work.
management.
2. On the Personas tab, click Add.
3. In the New persona window, in the Persona name field, provide a descriptive
name for your persona.
For example:
Enter HR worker.
4. Select an avatar to represent the persona.

5. Optional: To provide more information about the persona, in the Description
field, enter additional text.
For example:
For an HR worker, enter A user that processes job applications.
6. Click Submit.

Result:
Your application saves a new persona and adds it to the Personas landing
page where you can view case types and number of users that you
associate with the persona.
For example:
The following figure shows a modal dialog box that you use to create a persona:
Creating a persona
What to do next:
Associate the personas that you create with your Microjourney. For more
information, see Associating personas with case types.
Related concepts


• Operators
• Learning about access groups
Related tasks
• Creating a team
Associating personas with case types

To clearly visualize the participants of your Microjourney®, associate personas with
case types in your application. By adding personas to a Microjourney, you communicate
which users are involved in each phase of your business process, and which channels
they can access.For example, for a hiring process, you can associate a candidate
persona and an HR worker persona. This association indicates that each persona can
access different portals in the case, different information about the process, and
perform different actions. While the candidate only provides personal details and
uploads necessary documents, the HR worker processes the details, runs background
checks, routes the case for approval to a manager, and resolves the case.
Before you begin:
• Define a case type. For more information, see Case types.

• To reuse existing personas, define personas for your application. For more
information, see Creating personas.
When you associate a persona with a case type, you create a draft relationship between
the persona and the case type. To start processing your case, you need to implement
the relationship by granting the persona access to channels.

2. In the Personas & Channels section of a stage in which you want to add a
persona, click Add persona, and then select a persona that you want to use:
Choices Actions
Create a new persona a. In the personas list, select New

persona.
b. In the New persona window, in the
Persona name field, provide a
descriptive name for your persona.
c. Select an avatar to represent the
persona.
d. Optional: To provide more
information about the persona, in
the Description field, enter
additional text.
e. Click Submit.
Select an existing persona In the personas list, select a persona that

you want to add.
3. Click Save.
Result:
Your case life cycle displays the personas that you can use when you plan your
application development. By default, App Studio creates a draft relationship
between the persona and a web channel that is at the top of the web channels
list in your application.
The following figure shows a case type with associated personas. Each persona
has access to a default channel.

Personas in a case type
What to do next:
To define channels that you want to provide for the personas, create draft
channel associations. For more information, see Associating personas with
channels.
Associating personas with channels

To ensure that the participants of your Microjourney® interact with your application in
the most relevant way, create draft relationships between personas and channels.

When you associate personas with channels, you clearly visualize what means of
communication your development team needs to implement to deliver an efficient and
flexible application.You can associate a persona with multiple channels, and then assign
the channels to different releases. For example, for a hiring process, you can associate
an HR worker with a web channel and a mobile channel. In the first release of your
application, the HR worker can process cases by using a web portal. In the second
release, the HR worker can then also work on a mobile device.
2. In the Personas & Channels section, locate the persona that you want to
associate with a channel, and then click Add channel.
3. In the channels list, select a channel type that you want to associate with the
persona, for example, Mobile.
Result:
If you already have a channel of the selected type in your application, App
Studio adds the channel below the persona.
4. Optional: To create a new channel, provide details for the channel:

a. In the Channel properties pane, in the list of available channels, select
Create new.
b. In the New channel dialog box, in the Name field, enter a short description
for your channel
For example:
Enter Job applications mobile processor.
c. Click Submit.
5. Optional: To change a channel assigned to the persona, in the Channel
properties pane, in the Portal list, select a different channel.

6. Optional: To plan when you want to include the channel in your Microjourney,
associate the channel with a release:
a. In the Additional details section, in the Release list, select the release.
b. Optional: To indicate how much time the development team needs to
implement the channel, in the Complexity list, select a relevant option.
Implementing a channel includes completing all the actions necessary for a

persona to begin using a channel, which are configuring a persona to access
the channel and case type, updating the stage in the case type to support
the required use case, and updating the channel so that the persona can
access it in this stage.
Channel complexity affects project estimations and expected development

duration.
c. Optional: To provide more information about a channel, in the Comment
text box, enter a short description.
d. When you implement the channel, select the Mark as done check box.
You implement a channel after you configure a persona, a case type, and the
channel itself, so that the persona can access the channel in the relevant
stage of the case type.
7. Optional: To associate more channels with the persona, repeat steps 2 through 6.
8. Click Save.
Result:
Your case life cycle displays the persona with a list of associated channels, as in
the following figure:

Sample persona
What to do next:
To start using personas in your application, give the personas that you create
access to channels. For more information, see Granting personas access to
channels and pages.
Related concepts
Related tasks
• Estimating application development
Granting personas access to channels and pages

Start your Microjourney® by giving the personas that you create access to relevant
portals and pages. By defining different types of access, you can monitor the actions
that your team performs. For example, you can ensure that only the personas that
represent managers can access the User Portal portal. By default, a persona has access
to all pages in your application.

Before you begin:
Create personas for your application. For more information, see Creating
personas.
management.
2. On the Portals & pages tab, locate the column of a persona that you want to edit.
3. In the Portals section, in the Default channel row, in the list, select a default
portal for the persona.
A user that you associate with the persona sees the default channel every time
they log in to your application.
4. Optional: To provide access to more channels, in the row that contains another
channel, select one or more check boxes.
5. In the Pages section, select the check boxes for the pages that you want to be
available for the user with the associated role.
For example:
If you select the A new case type, Documents, and Reports pages for a role,
the users with this role can access only these pages.
6. Click Save.
For example:
The following figure shows a matrix that you use to define persona access to
channels and pages:

Configuring access for personas
What to do next:
Define what actions each persona can perform on a case at run time. For more
information, see Configuring access options for a persona.
• Defining areas of expertise for a team
Configuring access options for a persona

Ensure that users in your application can perform actions that are relevant to their role
by defining what options are available to specific personas. By configuring access on a
persona level, you accelerate your application development because you configure
options for entire groups of users.Personas represent distinctive types of users, for
example, managers or customer service representatives (CSRs). In a sample scenario,
you can grant a manager persona the possibility to open a case to view the case values
and progress, while a CSR persona can open and then modify a case to provide
updated values.

Before you begin:
Provide access to case types for a persona. For more information, see Granting
personas access to channels and pages.
management.
2. On the Personas tab, select the persona that you want to configure.
3. On the Access tab, select an element to which you want to configure access:
• To configure access to case types, select Case types.
• To configure access to data objects, select Data objects.
• To configure access to configuration sets, select Configuration sets.
4. In a row with an element that you want to configure, click Configure access.
5. In the Configure access to window, select the actions that you want to grant to
the persona:
• To allow a persona to view a case, select the Open check box.
This option is available only for case types.
• To allow a persona to generate an aggregated list of elements at run time,

for example a list of open cases of the selected case type, select the Run
reports check box.
• To allow a persona to modify an element at run time, for example to change
the value of properties of a data object or to update information in a case,
select the Modify check box.
To modify a case, also select the Open check box to ensure that the persona
can open the case.
• To allow a persona to view how values change throughout case processing,

select the View audit history check box.
Selecting this option affects all case types in your current workpool.

• To allow a persona to delete a data object, select the Delete option.
This option is available only for data objects.
6. Click Save.
Result:
On the Access tab, you can view the actions that are available to the persona in
every case of a given case type. If you specify any access control policies that
define actions that users can perform on cases and data objects, you can
preview the policies for every case type and data object. The policies override the
options that you specify on the Access tab. For more information, see Creating
an access control policy.
For example:
The following figure shows an access configuration for an HR persona. In the

example, the configuration defines actions that the persona can perform on
specific case types.
Access configuration for a persona


• Enabling field-level auditing
Creating personas with developer portal access

To deliver a flexible application that is useful even in the complex and advanced
scenarios, create personas that have access to developer portals, such as App Studio.
When personas use developer portals, they can be involved in both creating and
processing work.For example, a manager can take part in a Microjourney® by
approving or rejecting cases. The manager might also add steps to the case life cycle to
adjust the process to changing requirements.
Before you begin:
Associate a developer portal with an access group for which you want to create a
persona. For more information, see Granting portal access to an access group.
By default, in App Studio, you can create personas without access to developer portals
to clearly distinguish between run-time and design-time application users.
1. In the navigation pane of Dev Studio, click Records.

2. Expand the Security category, and then click Access Group.
3. In the list of the access group instances, select the access group for which you
want to create a persona.
4. In the Persona section, click Create persona with this access group.
5. In the Create persona dialog box, click Submit.
6. To manage the persona access to channels in App Studio, in the Available roles
section, select the Enable access configuration in App Studio check box.
7. Click Save.
Result:
The persona can access a developer portal defined in the access group as well as
channels defined in the persona settings in App Studio.

Related concepts

• Learning about access groups
Providing information about application user

Make your application more relevant to run-time users by providing meaningful data,
such as personal and professional information. You can also define an organizational
structure and assign skills and proficiency levels to users. As a result, reporting and
routing capabilities in your application work more efficiently.For example, you can add
a telephone number to a user to provide immediate communication when necessary.
You can also define a user as a fluent French speaker to ensure that your application
can accurately route tasks that require a high level of French.
Before you begin:
Invite users to use your application. For more information, see Inviting
collaborators to your application.
management.
2. On the People tab, in the Name column, click the user that you want to edit.
3. In the Personal information section, provide the contact information of the user:
a. In the Full Name field, enter the name and surname of the user.
b. Optional: To enable communication by email, in the Email field, enter the
email address of the user.
c. Optional: To enable sending push notifications and SMS messages, in the
Telephone field, enter the phone number of the user.
4. In the Professional information section, provide the organizational information
of the user:
a. Optional: To inform users how to address the operator, in the Title field,
enter a relevant personal title.

b. In the Persona / Developer role list, select a role that describes the type of
duties that the user performs in the application.
For example:
Select HR worker.
c. In the Business unit field, select the organizational unit to which the user
belongs.
d. Optional: To facilitate reporting in your organization, in the Reports to field,
enter the reporting manager of the user.
Result:
A reporting manager can receive notifications, for example, when the

user misses a goal or a deadline.
5. In the Skills section, assign a skill and a level of proficiency to the user:
a. Click New skill.
b. In the Skill field, enter the skill that you want to assign.
For example:
Enter French language.
c. In the Proficiency field, enter an integer that indicates the expertise level of
the user.
For example:
To indicate that the user speaks French fluently, enter 10.
6. Click Save.

For example:
The following figure shows a sample set of information about a user of an

application. The user is an HR worker associated with an HR operations unit, and
the French language skill of the user is rated at 10.
Information about a user
• Providing information about application user

• Operators
• Identifying people involved in case types
Adding data objects to organize data

Identify and manage the data that your Microjourney® requires by creating data
objects for your case types. When you ensure that users of your application have all of
the information required to process business cases, you speed up case resolution and
maximize work efficiency.
Adding data objects to your case life cycles creates draft relationships between the data
and your business processes. By examining these draft relationships, you can optimize

work by estimating what information a specific case requires and then planning how
you can acquire this data. For example, if your case represents a hiring process that
includes a Collect personal details stage, you can create draft data objects such
as Address information and Insurance details. As a result, when building your
application, you can clearly visualize the information that is essential to case resolution
and clearly communicate the objective to your development team.
To provide complex solutions for your case types, you can also capture data from
external systems. For example, in a hiring process, you can include a candidate's profile
from an external web page.
The following figure shows a process of collecting information in a case type with
associated draft data objects. Address information and insurance details data objects
imply sourcing information from a local Pega database, while a candidate's profile
comes from an external database.


draft data objects
What to do next: Plan and implement data objects in your application by completing
the following tasks:
• Associating data objects with case types
• Implementing draft data objects
• Associating attachment categories with case types
Related information
• Creating a data relationship
Associating data objects with case types

Provide the transparency of data that a Microjourney® requires by associating data
objects with case types. When you define which data objects you need to create to
process your business case, you improve the overall planning and development of your
application.
Before you begin:
• Create a case type, and then populate the case life cycle with stages,
processes, and steps. For more information, see Adding case types to
organize work.
• Create personas that visualize groups of users of your application. For
more information, see Adding personas to organize users.
When you associate a data object with a case type, you create a draft relationship
between the object and the case type. Visualization of this relationship helps your team

understand what data objects they need to define, so that users of your application can
begin their Microjourney. For example, in a case type that represents a hiring process,
you can associate data objects for Personal details and Contact details with a Collect
personal details stage.
2. In the Data & Interfaces section of a stage in which you want to add a data
object, click Data, and then select a data object that you want to use:
Choices Actions
Create a new data object a. In the list, select Data object > New
data object.
b. In the New data object window, in
the Name field, enter a descriptive
name for the data object.
c. Click Submit.
Select an existing data object In the list, click Data object, and then
select the data object that you want to
add.
By default, App Studio associates data objects with the Pega integration system.
3. Optional: To associate the data object with a different integration system, click
the system name, and then in the System section, in the Select system list, select
a different system:
Choices Actions
Create a new system a. In the list, select Create new.

b. In the New system dialog box, in
name for the system.

Choices Actions
For example:
Enter LinkedIn.
c. Click Submit.
Select an existing system In the list, select the system that you want
to use.
4. Optional: To indicate that the application reads the data object from the system,
select the Read check box.
5. Optional: To indicate that the application updates the data object in the system,
select the Write check box.
Your application can both read and update data in the system.
6. Optional: To indicate that the external system that you want to use has defined
APIs, in the System details section, select the Existing API check box.
Using existing APIs affects project estimation and shortens the estimated
development duration.
7. Optional: To communicate when you want to include the data object in your
Microjourney, associate the data object with a release:
implement the data object, in the Complexity list, select a relevant option.
Implementing a data object includes defining fields in the data object,

defining the system, defining the data page that the use case requires, and
defining a case type to include the data object in an assignment or other
type of step.
The complexity of the data object affects project estimation and expected

c. Optional: To provide more information, in the Comment text box, enter a

short comment.
d. When you implement the data object, select the Mark as done check box.
e. Click OK.
8. Optional: To add more systems to the data object, in the Data & Interfaces
section, locate the data object that you want to associate with another system,
click System, and then define the system details:
Choices Actions
Create a new system a. In the list, select New system.

b. In the New system dialog box, in
name for the system.
For example:
Enter Job opportunities.
c. Click Submit.
d. Repeat steps 4 through 7.
Add an existing system a. In the list, select the system that you
want to use.
b. Repeat steps 4 through 7.
9. Click Save.
Result:
Your case life cycle displays draft data objects that you can use when you plan
development of your application.

For example:
The following figure shows an Address information data object in a case life cycle
and sample configuration of the draft data object:
Draft data object
What to do next:
Turn the draft data associations into permanent data objects that you can use in
your application. For more information, see Implementing draft data objects.

• Data modeling
• Integration systems
Implementing draft data objects

Provide data that is necessary to process your business cases and meet your goals by
implementing draft data objects. When you plan your Microjourney®, you can associate
draft data objects with case types. By turning these data objects into permanent
elements, you ensure that your customers can process the Microjourney successfully.
Before you begin:
Create draft data objects that visualize information that your Microjourney
requires. For more information, see Associating data objects with case types.
1. In the navigation pane of App Studio, click Data.

2. Click Data objects and integrations.
3. Click a draft data object that you want to persist.
Draft data object names have (Draft) appended to a descriptive name, for
example Address information (Draft), as shown in the following figure:
Draft data objects

4. In the Data model section, click Create data model.

5. In the Create new data model field, enter the name for the type of information
that you want to model.
6. In the Define source data field, define a location for your data by selecting one of
the following options:
• To set a local Pega data object, select Now, and then select Pega in the
Systems list.
By connecting to Pega database storage, you can add fields and complete
your data model. When your data model is complete, and your external data
sources are available, you can optionally connect to them too.
• To define a source system later, for example if your source system is not yet
ready, select Later.
7. Click Submit.
What to do next:
• To prioritize work and start implementing draft relationships defined

during planning your Microjourney, analyze your application inventory. For
more information, see Managing application inventory.
• To provide meaningful information for your data object, define fields. For
more information, see Creating fields for capturing data.
• Data modeling
Associating attachment categories with case types

To ensure that the workers who process your Microjourney® have the relevant
information, associate attachment categories with your case type. Visualizing the
attachments required by your Microjourney helps you to gain a better overview of the
information that your application users need to deliver. You can also communicate to

your stakeholders what documents or other attachments are crucial in the

Microjourney.For example, in a hiring process, you can indicate that a job applicant
should provide scanned documents, for example letters of recommendations.
When you add an attachment category to your case life cycle, you create a draft
relationship between the attachment category and the case type. Draft relationships
affect project estimation and clearly visualize which application elements you need to
implement, and as a result, help you to plan your application development.
2. In the Data & Interfaces section, click Add data object > Attachment, and then
define the attachment category:
Choices Actions
Use an existing attachment category Select the attachment category from the
list of categories.
Create a new attachment category a. Click New attachment category.

b. In the New attachment category
dialog box, in the Name field,
provide a descriptive name for the
attachment category.
For example:
Enter Letters of
recommendation.
c. Click Submit.
3. Optional: To add more categories for the attachment, click Category, and then
repeat step 2.
For example, you might need more attachment categories when you need a
document in a printed version and as a digital file.

4. Optional: To communicate when you want to include the attachment in your

Microjourney, associate the attachment category with a release:
implement the attachment, in the Complexity list, select a relevant option.
Implementing an attachment category includes defining storage options and

editing the case life cycle to include the attachment in an assignment or
other step type.
The attachment category complexity affects project estimation and expected

c. Optional: To provide more information, in the Comment text box, enter a
short description.
d. When you implement the attachment category, select the Mark as done
check box.
5. Optional: To change the attachment category, in the Category properties pane, in
the Select category list, select a different category.
6. Click Save.
Related tasks
• Attaching content to a case

• Attaching screen captures to a case
The Microjourney in the Pega Express delivery

approach FAQ
Reach your business goals faster and with greater effect by understanding and
implementing the Pega Express™ delivery approach while planning your
Microjourney®.

What are the key elements of a Microjourney?
Your Microjourney includes the following key elements:
• Case types that are reusable templates of your business processes

• Personas that represent parties that interact with cases through channels
• Data objects that you need in order to process a case
For example, if your business objective is to review job applications, you can create a
Hire a candidate case type, and then associate the following personas with the case
type:
• A job applicant that uses a Job Bot portal

• A staffing consultant that uses an HR Connect portal
• A hiring manager that uses the User Portal
Data that you need to process a hiring case might include a candidate's personal
details, education, and work experience.
For a holistic understanding of your customers' needs, you can now visualize these
three elements on one screen when you design a case type in the Case Designer tool in
App Studio. For more information, see Creating a Microjourney for customer success.
What do I need to do to start planning my Microjourney?
To associate personas and data objects with case types, you need to update your
application to support the Pega Express delivery approach. When you open your
existing application, a prompt to update your application is displayed. When you create
a new application, it already supports planning a Microjourney. For more information
about the update, see Application update scenarios for the Pega Express delivery
approach.

Do I need to update my built-on applications first?
Yes, you need to update your built-on applications first if they include data objects that
your current application uses. If you update your built-on applications first, when you
update your current application, the current application only references the data
objects from your built-on applications.
When you update your current application first, it creates the data objects that it uses
from the built-on applications. If you update your built-on applications later, it
duplicates the data objects. As a result, when you start by updating your built-on
applications, you save time and resources.
Do I need to update UI Kit or PegaRULES built-on applications as well?
No, because UI Kit and PegaRULES built-on applications do not include any data objects
or personas.
How do I prepare for an update?
For an update, you need an unlocked ruleset or you need to enable branch
development. Otherwise, you get an error message about no unlocked rulesets or
versions and the update fails. For more information, see Organizing rules into rulesets
and Setting branch development preferences.
Where can I find the Roles landing page in App Studio?
For greater clarity, two new landing pages replace the Roles landing page: Personas and
Access. The Personas page lists all the personas from your application, and the Access
page contains a matrix that you use to provide the personas with access to various web
channel and pages.

Do the new landing pages affect my existing access configurations?
No. The introduction of the Personas and Access landing pages has no impact on your
existing access configurations. After you update your current application, you can view
the settings that your application migrates from the Roles landing page.
Does the Personas landing page list all the roles from a previous
version of my application?
No, the Personas landing page lists only roles that interact with your application
through a channel. When creating personas during an update, your application ignores
the development roles that have access to Dev Studio, App Studio, Admin Studio, and
Prediction Studio, such as administrator or author.
Does my application create personas for all access groups?
Yes, your application creates personas for all access groups without requiring access to
the development portals, such as Dev Studio.
What happens to my data types after an update?
After you update your application, your data types persist and change into data objects.
If your framework and implementation applications have data types with the same
labels, and you enable branch development, merge the branch to your framework
application first before you update your implementation application. Otherwise, the
system fails to create data objects for the implementation application.
When I create a new application, which elements of a Microjourney

does it include?
When you create a new application without built-on applications, your new application
includes:
• Two default personas, Users and Managers.

• No data objects.
• Four default releases.

When you create a new application with built-on applications, your new application
includes:
• Data objects that your applications references from built-on applicationss.

• Personas that your application references from built-on applicationss. The
included Personas are specific to the current application.
• Personas that your application creates from access groups in the built-on
applications. Your application ignores the access groups that have access to the
development portals, such as Dev Studio.
• Relationships between personas and web channels that your application
references from the built-on applications.
• Four default releases.
For relevant training materials, see the Pega Express introduction module on Pega
Academy.

• Data modeling
Designing and tracking Microjourneys

development
Application development often requires the cooperation of multiple participants, such
as the members of a development team and business stakeholders. A development
road map and tracking system that all involved parties can understand help you deliver
software that meets business requirements in the most efficient and suitable way.
Consider the following factors when you plan application development and search for
the method of tracking progress:

Implementation methodology
Implementation methodology dictates how a development team plans and tracks work.
The methodology also affects how the development team communicates progress to
other stakeholders and how often stakeholders provide feedback on the development
process. Pega Platform™ supports the scrum methodology as an agile approach that
promotes an iterative and flexible development process.
Application development estimates
In App Studio, you can quickly and conveniently estimate the resources that the
development process requires and how different factors affect the duration of the
process. For shared understanding, you can export the estimates to an .xls file to share
offline with stakeholders that do not have access to Pega Platform.
Feature-based application development
For more granular, scalable, and flexible application development, Pega Platform
supports a development process based on features. Each feature represents a
functionality that a development team needs to implement to deliver results defined
with stakeholders, such as actions that users perform in a business process or
elements of user interface. When you implement feature-based development, you can
easily track progress by not only checking which features are done, but also by
requesting a feature enhancement or a bug. Feature-driven application development is
compatible with scrum and helps your development team plan and track work even
more efficiently.
For example:
The following figure shows a sample banking application that consists of four
features:
• case types
• UI portals

• language packs
• data objects
Before the development process starts, a development team can estimate

resources that implementing each feature requires. Then the team can track
progress by checking which features are ready for production. Finally, feature-
based development provides an option to raise issues or feedback items
regarding each feature.
Application features
Start designing and tracking your application development by performing the following
tasks:
• Managing application inventory

• Feature-driven development tracking
Estimating application development

For more accurate project planning and enhanced communication with your
stakeholders, create application development time estimates. When you estimate the
duration of your project, you clearly state how much time and effort your development
team needs to deliver an application that reflects its specific design and required
elements.
Before you begin:
Define the main elements of your application:
• Create a case type, and then define the case life cycle by adding stages,
• Create personas that represent users of your application. See Adding
personas to organize users.
• Create data objects that visualize the information that your cases require to
reach the resolution stage. See Adding data objects to organize data.
• Create features that represent usable functionalities in your application.
See Creating features.
A project estimate considers various factors, such as the complexity of the application
elements, the number of available teams to work on developing the application, and
having a configured development environment to build your application. The creation
of estimates in Pega Platform is automated. After you provide the required values, the
project estimator calculates the expected development duration. To share the
estimation results with stakeholders outside Pega Platform, you can export the
estimates into an .xlsx file.

2. In the Application profile section, click Manage.

3. In the Application profile workspace, click Estimator.

4. In the Estimator section, in the Release list, select the release for which you want
to calculate the estimate.
For example:
Create a collective estimate for all defined releases by selecting All.
5. In the Delivery list, select the implementation method that your development
team uses.
For example:
Select Scrum/Agile.
Non-Agile methodologies increase the estimated effort and duration by 20%.

6. In the Number of teams field, specify how many teams can work on the project.
7. In the Scrum maturity list, select a value that describes the customer's experience
with scrum projects.
Medium maturity increases the estimated effort and duration by 7.5%, and low
maturity by 15%.
8. In the Staffing model list, select a value that indicates the level of cooperation
between the customer and Pega.
In the co-production model, it is assumed that a business architect and two
system architects from the customer side join each development team.
9. In the Environment list, select the environment on which you want to deploy the
application.
Creating a new on-premises environment elongates the estimated effort and
duration by 10%.
10. In the Organization complexity list, select an option that indicates how many
levels and regulations your organization has.

Organizations with high complexity comply with external regulations and

additional validation requirements, such as government organizations and those
in the financial, healthcare, and pharmaceutical industries.
A high complexity level increases the estimated effort and duration by 20%.
11. In the Data import effort list, select an option that describes the complexity level
of the effort required to migrate data from the legacy system to the new Pega
system.
A high complexity level increases the estimated effort and duration by 30%,
medium by 20%, and low by 10%.
12. Click Calculate estimate.
Result:
The estimator calculates the expected development duration in hours and

weeks, with a division between Pega and customer hours. The estimator
also includes detailed information about the number and complexity of the
items in your application, such as case types, personas, data objects, and
features.
13. Optional: To import the estimate to an .xlsx file, in the Application overview
workspace header, click Actions > Export estimate as .xlsx file.
Result:
App Studio automatically saves the .xlsx file to your machine.
For example:
The following figure shows the estimator tool with calculations for a sample
application development process. The calculations focus on the first release of
an application and a team that works in scrum and has high scrum maturity.

Estimator
Related concepts
Related tasks
• Creating a top-level case type

Adopting feature-driven development

Develop capabilities in the context of a feature to maintain functional requirements and
project status directly in your application.
Before you begin:
Ensure that you have the PegaRULES:AgileWorkbench access role and the
pxAgileWorkbench privilege.

As a best practice, use Agile Workbench to manage feature-driven development

because work items provide traceability from features to the rules that support them.
• Feature order
• Creating features
• Creating subfeatures
• Reviewing application features
• Changing feature levels
• Requesting feature enhancements
• Creating bugs to report feature defects
• Associating rules with features
• Associating a feature with a work item
• Skimming features to the latest version
• Deleting a feature
• Creating project documents for stakeholders in Dev Studio
Feature order
To understand the importance of the features in your application, look at the order in
which your application lists features. Your application lists features in order of
relevance to the current implementation, with the oldest features at the top by default.
When you update an application, it retains the features from previous versions of the
application, as well as from built-on applications. You can reorder features from
previous or built-on applications in your current version, which by default your
application lists in the following order:

1. Features from the current version of your application: from the oldest to the
newest.
2. Features from earlier versions of your application: based on the order of features
in those versions.
3. Features from built-on applications: based on the order of features in those
applications.
If you have multiple built-on applications, the features follow the order from the
built-on application stacks.
To override the default order and emphasize the features that are most important in
the current version of your application, you can manually reorder features.
When you reorder the features in either an earlier version of your application or a built-
on application, the current version of your application also reflects the changes, unless
you customize the default order in the current version.
When you reorder the features in the current version of your application, the new order
overrides any other changes that you make to feature order in earlier versions of your
application or built-on applications.
You can also reset a custom feature order, back to the default order.
The system places new features that you add to your application at the end of the list of
features.
The following figure shows a part of a feature map with features from a current
application and built-on applications in a default order:

Feature map

• Creating stories
Creating features
Ensure that your application supports capabilities that meet your specific business
needs and customer expectations, by creating features. When you create features, you
communicate what elements your development team needs to implement to deliver a
complete application, so that you can appropriately plan your work and inform
stakeholders about your application design.For example, you can create features that
represent language packs and case types to ensure that you deliver an application that
meets the requirements defined with your stakeholders. During application
development, your team turns features into usable functionalities.
1. In the header of Dev Studio, click the name of the application, and then click
Overview.
4. In the Application profile workspace, click the Feature map tab.
5. In the header of the Features section, click the Create icon.
6. In the Name field, enter text that uniquely identifies the feature.

7. In the Description field, enter text that describes the business value for this
feature and provides an overview of what users can do when the development
team implements the feature.
8. Click Create.
For example:
The following figures show a modal dialog box with a sample description of a
new feature and a list of features with the latest feature at the end:
Creating a new feature

Feature map
What to do next:
Extend the capability with additional capabilities by creating subfeatures. For

more information, see Creating subfeatures.
Creating subfeatures
Provide more advanced and varied solutions in your application by enhancing
application features with subfeatures. Create a subfeature to define a capability that
extends another capability.For example, you can create a feature that describes
reporting and monitoring, and then extend that feature with subfeatures for business
reporting and analytics monitoring.
Before you begin:
Create a main feature that you want to expand. For more information, see
Creating features.

3. In the Application profile workspace, click the Feature map tab.

Overview.
5. In the Features section, click the name of the feature that you want to
supplement with a subfeature.
6. In the Subfeatures section, click the Create icon.
7. In the Name field, enter text that uniquely identifies the subfeature.
8. In the Description field, enter text that describes the business value for this
subfeature and provides an overview of what users can do when the development
team implements this subfeature.
9. Click Create.
For example:
The following figure shows a Reporting and monitoring feature with two
subfeatures: Business reporting and Analytics monitoring:

Subfeatures
What to do next:
Extend the subfeature with additional capabilities by creating additional nested

subfeatures. You can create four levels of subfeatures.

Reviewing application features

Review the current features in your application so that you can make informed
decisions about the new features and subfeatures that you create. To access more
information about your features, review them by switching to a tree view.For example,
by using a tree view you can view the stories, bugs, and feedback items associated with
a feature, so that you can plan your work accordingly and ensure that you deliver an
application that meets all your business requirements. You can also check whether a
feature belongs to your current or built-on application.
Overview.
3. In the Application profile workspace, click Manage.
4. In the Application profile workspace, click Feature map.
5. In the Features section, click the Switch to tree view icon.
6. Expand the list of features, and then review the subfeatures that extend your
features.
7. In the Version column, review the application type to understand which features
are unique to your application and which features you inherit from other built-on
applications or versions.
8. Optional: To get the status of a feature, analyze the progress bar in the Progress
column.
9. Optional: To open items associated with the feature in the Agile Workbench tool,
in the Progress column, click a relevant icon.
For example:
The following figure shows an overview of features in an application with a

progress bar and a number of user stories , bugs , and feedback items

that remain to implement. The Reporting and monitoring feature is

expandable and includes two subfeatures.
Feature overview
Related tasks
• Managing application inventory
Changing feature levels

Change the relative position of a feature in the hierarchy to support their reuse and
extension in other applications. The feature order and the relationships between
features and subfeatures reflect how important features are and how different features
correlate with each other.

Before you begin:
Learn how a feature order corresponds with significance of different features.

For more information, see Feature order.
Overview.
4. In the Application profile workspace, click Feature map.
6. Review the different levels in your feature hierarchy by expanding the list of
features and subfeatures.
7. Change the feature position:
• To move a feature up or down in the feature list, drag the item into a new
position.
• To turn a feature into a subfeature, drag the feature over the top-level
feature.
• Associating rules with features
Requesting feature enhancements

Improve and adjust an application to your specific business needs by requesting a
feature enhancement. You request an enhancement by creating a feedback item. Your
development team triages feedback items and decides whether to implement or reject
the enhancement, based on priority and available resources.

Before you begin:
To provide context for the team and to speed up feature development through
videos or screenshots, log in to your application in Google Chrome by using the
HTTPS protocol.
1. In the header of App Studio, click the Toggle developer assistant icon.
2. Optional: To record a video or take screenshots, in the Agile Workbench tool, add
the Pega Screen and Video Capture extension to your browser by clicking Install
the plugin at the bottom of the tool, and then following the instructions in Google
Chrome.
3. In the header of the Agile Workbench tool, click Create work item > Create
Feedback.
4. In the Name field, enter text that summarizes the change.
5. In the Description field, enter text that includes the rationale for the change and
details, such as use cases or metrics, that can help the team decide how to triage
the feedback.
6. In the Associated feature list, select a feature that relates to the enhancement.
7. In the Priority field, select the relative importance of the enhancement.
During triaging the development team uses this field to determine when they
implement the feedback relative to other items in the product backlog.
8. Optional: To add an attachment, click Add attachment, and then select the
attachment type:
Choices Actions
Record a video a. On the Attachments menu, click

Record video.
b. In the Share your screen window,
select a screen that you want to
record, and then begin the recording
by clicking Share.

Choices Actions
c. In the timer window, stop the

recording by clicking Stop.
Take a screenshot a. On the Attachments menu, click

Capture screen.
b. Drag the target pointer onto the
screen area that relates to the
feature enhancement.
c. In the text field below the target
pointer, enter additional
information about the bug, and then
click Capture screen.
d. In the Share your entire screen
window, select a screen that you
want to capture, and click Share.
Attach a file a. On the Attachments menu, click

Attach files.
b. In the Attach file(s) window, select
the files that you want to upload,
and then click Attach.
Attach a URL a. On the Attachments menu, click

Attach URL.
b. In the Attach a link window, in the
Name field, enter a descriptive
name for a URL.
c. In the URL field, enter the URL.
d. In the Attachment category list,
select URL.
e. Click Submit.
9. Click Save.

For example:
The following figure shows a sample feedback item that captures a requirement
to provide alternative dates when a user books a stay at a hotel and the selected
dates are unavailable:

Sample feedback item
What to do next:
Discuss the feedback item with a development team. For more information, see
Collaborating with development teams.

• Triaging a feedback item
Creating bugs to report feature defects

Improve your application by identifying any issues that might have a negative impact
and creating bugs that report feature defects. When you create bugs, your
development team can track the defects, and then fix the issues to deliver an effective
product.
Before you begin:
HTTPS protocol.
1. In the footer of Dev Studio, click the Agile Workbench icon.

3. Optional: To record a video or take screenshots, in the Agile Workbench tool, add
the Pega Screen and Video Capture extension to your browser by clicking Install
Chrome.
4. In the header of the Agile Workbench tool, click Create work item > Create bug.
5. In the Name field, enter text that summarizes the issue.

6. In the Description field, enter text that includes steps to reproduce the bug, and
any supporting information.
For example:
You can provide the credentials to your application, which can help the
team fix the bug more quickly.
7. In the Associated feature list, select a feature that relates to the bug.
8. In the Due field, select a deadline for bug resolution.
9. In the Severity field, click an option that indicates the extent to which the bug
affects your application.
10. Optional: To speed up bug resolution, in the Owner field, assign the bug to a user
by entering a user ID.
attachment type:
Choices Actions

Record video.
by clicking Share.

Capture screen.
screen area that shows the bug.

Choices Actions
information about the bug, and then

click Capture screen.
want to capture, and click Share.

Attach files.

Attach URL.
name for a URL.
select URL.
e. Click Submit.
12. Click Save.
For example:
The following figure shows a bug in Agile Workbench that reports an issue with
loading one of the screens in a case type:

Sample bug

What to do next:
Discuss the bug with a development team. For more information, see
Triaging a feedback item

Actively triage feedback items to create relevant work items that you can track to
closure. For example, you can create a user story to track work on an enhancement
that a stakeholder requests through a feedback item, or a bug to track fixing an issue
that the feedback item describes.

3. In the Agile Workbench header, click Feedback to view a list of feedback items.
4. Click the name of a feedback item.
5. In the Description field, review the requested feature enhancement.
6. Consult your product owner to determine whether to implement the
enhancement.
7. In the bottom toolbar of the Agile Workbench, click Mark as..., and then select an
option, based on your decision.
• To exclude an enhancement from the development scope, click Reject.
• To create a new story that you can populate with tasks to deliver the
enhancement, click New Story.
• To create a bug to fix an issue that the feedback item describes, click New
Bug.
Tip: You can also triage a feedback item directly from the list of feedback
items, as in the following figure:

Triaging a feedback item
8. Provide details in the work item that you create from the feedback item.
For more information, see Creating bugs to report feature defects and Creating
stories.
9. Click Save.
Result:
If you integrate Agile Workbench with Agile Studio, the stories and bugs are
available in Agile Studio.

Associating rules with features

Document the rules that implement a feature to improve the traceability and
extensibility of your application. When you associate a feature with a rule, you can
conveniently check which elements exactly build your application, so that you can make
informed decisions when you decide to reuse a feature in another application.For

example, you can associate a feature that represents your business process template
for reviewing loan requests with rules that define a case type, a service-level agreement,
and an email message. As a result, you get a holistic view of the elements that build
your feature.
Note: Associating rules with features is available only in Dev Studio and is
suitable for advanced developers that need a more detailed analysis of their
application elements. You can continue your low-code application
development in App Studio without associating rules with features.
Overview.
2. In the Features section, click the name of a feature.
3. On the Associated rules tab, click Add rule.
4. In the Type field, press the Down arrow key, and then select a rule type to narrow
the list of rules that you can select.
For example:
Select Case Type.
5. In the Name field, press the Down arrow key, and then select the rule that you
want to associate with the feature.
For example:
Select Review loan request.
Tip: To narrow the list of results and help you decide which rule to
choose when more than one rule has the same name, you can enter a
class name in the Applies to field. Otherwise, the system autopopulates
the Applies to field.

Result:
Your application manages the links between features and rules as the
development process advances. When you create a rule by copying or
specializing another rule, your application copies the links from the original rule
to the features of the new rule. For example, when you associate a Language
pack feature with a Loan request case type rule, and then copy the Loan request
case type rule, your application automatically copies the link between the
Language pack feature and the new case type rule. When you delete, withdraw,
or block a rule, your application removes the links from the features.
The following figure shows an association between a feature and a case type
rule:
Rule associated with a feature
• Reviewing application features

• Creating rules
• Creating a rule specialized by circumstance

Associating a feature with a work item

Improve the traceability of your application development by associating your assigned
work items with the features that the work items implement. You can associate a
feature with a user story, a bug, or a feedback item.For example, if one of the features
represents creating a case type to review loan requests, you can create a user story to
track the progress of the case type creation.
Before you begin:
Create a work item that you want to associate with a feature. For more
information, see:
• Creating stories

3. In the header of the Agile Workbench tool, click the type of work item that you
implement.
You can implement a user story, a bug, or a feedback item.
4. In the list of work items, click the item that you want to open.
Tip: To quickly find a work item in a long list, use the search tool, sort the
list, or filter the list by feature.
5. In the Associated feature list, select a feature that you want to associate with the
work item, and then click Select.
6. Click Save.

Result:
• When you open the feature overview, in the Work items section, you can
see the work item that you associate with the feature, as shown in the
following figure:
Feature associated with a user story
• If the feature that you choose is not in your current application version, the
system promotes the feature to your current application version.
Skimming features to the latest version

Copy, or skim, features from previous versions of your application to ensure that the
application that you ship includes the complete feature hierarchy.

1. Log in to the latest version of your application.

Overview.
4. In the Features section, click Actions > Skim previous features.
5. Click Yes, skim features.
6. In the Version column, verify that all features are associated with your current
application.
Deleting a feature
Delete features when they are unused or no longer relevant. For example, when you
de-scope a feature from your application development, you can delete the feature to
ensure that you strictly follow the latest requirements for the application that you want
to deliver.
Before you begin:
Ensure that the feature that you want to delete does not have any of the
following characteristics:
• Inherited from a built-on application
• Defined in a previous version of your application
• Associated with open work items
• Contains subfeatures that are defined in your current application
In these scenarios, the option to delete a feature is unavailable.


3. In the Application profile section, click the Feature map tab.
4. In the upper-right corner of the Features section, click the Switch to tree view
icon.
5. Expand the list of features and subfeatures to find the feature to delete.
6. Click the Delete icon.
Managing application inventory

Plan the development of your application, manage the workload in your team, and
prioritize your work accordingly by following the application backlog on your Inventory
landing page. The Inventory landing page lists features, personas, and draft data
associations across your Microjourney, so that your team can map items to specific
releases.
By analyzing the application inventory, you can also determine how different elements
of your application, such as personas and case types, interact with each other.
You associate personas and data objects with case types when you plan your
Microjourney. By making these associations, you can clearly visualize the data and
participants that your business processes require. After you create these associations,
or draft relationships, you can analyze your application inventory, so that you can
prioritize work by checking releases associated with personas and data objects. You can
also group and filter personas and data objects for a better understanding of how
these elements are related. For more detailed planning, on the Inventory page, you can
also manage your application features. For example, you can associate a feature with a
release, so that you can estimate your work more accurately.

Before you begin:
Define the main elements of your application:
• Create a case type, and then define the case life cycle by adding stages,
• Create personas that represent users of your application. See Adding
personas to organize users.
• Create data objects that visualize the information that your cases require to
reach the resolution stage. See Adding data objects to organize data.
• Create features that represent usable functionalities in your application.
See Creating features.

3. On the Inventory tab, in the Inventory section, select the items of information
that you want to view:
• To manage draft personas, click Persona.
• To manage draft data objects, click Data.
• To manage application features, click Features.
4. Organize the list of items to display only the information that you need:
• To group items, click Group, and then select the grouping method that you
want to apply, for example Complexity.
• To display only selected information about items, click Fields, and then select
the fields that you want to display, for example Channel and Status.
• To change how the information is displayed, click Density, and then select a
format that you want to apply, for example Compact.
5. Update the information to reflect the latest changes that you make in your
application by clicking Edit details, and then performing the following actions in
the Edit details window:

• To change the iteration of your application in which you want to implement

the item, in the Release list, select a release.
• To change the amount of time that the development team needs to
implement the item, in the Complexity list, select a new value.
• To provide more information about an item, such as business value, in the
Comment text box, enter some additional description.
• To mark the item as implemented, select the Mark as done check box.
6. Click Submit.
For example:
The following figure shows the Persona of an application inventory with

personas associated with case types in the application. In the example, the
inventory applies grouping by a case type.
Application inventory
• Creating a team

Adding features to application inventory
Get a quick overview of the functionalities that your development team needs to
implement by adding features to your application inventory. When you analyze your
application inventory, you can conveniently plan your application development in a
more detailed way.For example, you can create features that represent language packs
and case types to ensure that you deliver an application that meets the requirements
defined with your stakeholders. During application development, your team then turns
features into usable functionalities.
Before you begin:
To reuse features, add built-on applications to your current application. For more
information, see Adding built-on applications.
You can assign each feature a complexity level. Complexity indicates the time and effort
that a team needs to implement a feature and impacts further estimation of the time
required for application development.
Overview.
4. In the Inventory section, click Feature map.
5. Add a feature to your application:
Choices Actions
Reuse a feature from a built-on a. Hover over the features list, and
application then click Add > Add from existing
features.
b. In the Add from existing features
dialog box, in the Feature list, select
a feature to reuse.

Choices Actions
c. Optional: To manage your features

in a more convenient way, from the
Category list, select a category that
best describes your feature.
For example:
Select Security.
d. In the Release list, associate the

feature with the iteration of your
application.
e. Optional: To modify the feature for
your current application, in the
Complexity list, select an option that
indicates how much time a
development team needs to
implement the feature.
Feature complexity impacts
estimation of project completion
time. Complex features elongate the
estimated application development
process.
f. Optional: To provide more
information about the feature, in
the Comment text box, enter some
additional description.
For example:
Enter text that describes the

business value of this

Choices Actions
feature and provides an

overview of what users can
do when the development
team implements the
feature.
g. Optional: To communicate that the

feature is ready, select the Mark as
done check box.
Features that you mark as done
have no impact on development
time estimations.
h. Optional: To add more features,
click Submit & add another, and
then repeat steps 5.b through 5.g.
i. Click Submit.
Create a new feature a. Hover over the features list, and

then click Add > Add new feature.
b. In the Add new feature dialog box,
in the Name field, enter some text
that uniquely identifies the feature.
c. Optional: To manage your features
in a more convenient way, from the
Category list, select a category that
best describes your feature.
For example:
Select Security.
d. Optional: To associate the feature

with the iteration of your

Choices Actions
application, in the Release list, select

a release.
e. To indicate how much time a
development team needs to
implement the feature, in the
Complexity list, select a relevant
option.
Feature complexity impacts
estimation of project completion
time. Complex features elongate the
estimated application development
process.
f. Optional: To provide more
information about the feature, in
the Comment text box, enter some
additional description.
For example:
Enter text that describes the

business value of this
feature and provides an
overview of what users can
do when the development
team implements the
feature.
g. Optional: To communicate that the

feature is ready, select the Mark as
done check box.

Choices Actions
Features that you mark as done

have no impact on development
time estimations.
h. Optional: To add more features,
click Submit & add another, and
then repeat steps 5.b through 5.g.
i. Click Submit.
6. In the header of the Features section, click the Click to create new feature icon.
7. In the Create feature dialog box, in the Name field, enter text that uniquely
identifies the feature.
8. Optional: To provide additional information, in the Description field, enter text
that describes the business value of this feature and provides an overview of what
users can do when the development team implements the feature.
9. Click Create.
For example:
The following figure shows the Features tab of the application inventory, with
features grouped by category:

Features in an inventory
What to do next:
Calculate the time and effort that you need to deliver your application. For more
information, see Estimating application development.
Related concepts
• Feature-driven development tracking
Related tasks
Feature-driven development tracking

With feature-driven development, you can create and manage stories that you
associate with features to track the progress of your team. As a result, you ensure that
you deliver results in a timely manner, within service-level agreements that you agree
upon with stakeholders.Feature-driven development helps you to track changes that
team members implement in given features. You can also determine and communicate
requirements for new features.
You track feature-driven development by implementing the following steps:
1. You create stories that capture functional requirements.
Tip: To save time, you can create stories in bulk. Associate stories with
features for more efficient and transparent tracking of your application
development.

2. You work with your development team to determine which story to implement,
based on project status and priorities.
3. You change the story status to Doing as the feature development starts.
4. You follow the instructions in the story to create the required logic, data, or
interface elements in your application.
5. You change the story status to Done when the feature development is complete.
You can use Agile Workbench to conveniently create and manage stories, as well as
bugs and feedback items that your application development might require. By using
Agile Workbench directly from your development environment, you can quickly capture
any functional requirements, and then share the requirements with your team.


Agile Workbench
You can also access related user stories, bugs, and feedback items directly from a view
of the feature in the feature map, as shown in the following figure:
Associated user stories
• Agile Workbench
• Integrating Agile Workbench with Pega Agile Studio
• Creating stories in bulk
• Collaborating with development teams
• Integrating Agile Workbench with Jira in Pega Platform from 8.3.x
• Integrating Agile Workbench with Jira in Pega Platform 8.1.x to 8.2.x
• Integrating Agile Workbench with Jira in Pega Platform 7.3.x to 7.4.x
• Changing statuses of work items

Agile Workbench
Agile Workbench is a tool for project stakeholders that captures real-time feedback
about your application and tracks feature development. By managing feedback and
development status directly in your application, you can make application development
more efficient.
You provide feedback by creating a work item that is a user story, a bug, or a feedback
item. Your feedback can contain videos, annotated screen captures, file attachments, or
URLs. Project stakeholders can view, update, and triage the work items that you create.
When you use Agile Workbench to create features, you can associate each feature with
a work item to establish traceability from requirement to implementation. You can also
configure Agile Workbench to integrate with Pega Agile Studio so that bugs and stories
are synchronized between the two systems. Within each work item, you can
communicate with other team members and stakeholder by using Pulse for
transparent and efficient application development.
The following figures show the Stories tab of Agile Workbench, which is part of the
Developer assistant pane, and an interface that you use to create a bug. The interface is
unified for all work items.

Agile Workbench in the Developer assistant pane and a sample bug form

• Setting your current work item
Integrating Agile Workbench with Pega Agile Studio

To synchronize work items, such as stories, bugs, and feedback items, between your
development environment and a project management tool, integrate Agile Workbench

with Pega Agile Studio.As a result, items that you create in Agile Workbench are
available directly in Agile Studio.
Before you begin:
Verify that your operator preferences provide a valid user ID for Agile Studio, as
shown in the following figure:
Project management operator ID
1. In the header of Dev Studio, click the name of your current application, and click
Definition.

2. Click the Integration tab, and then, in the Agile Workbench integration section,
click Configure integration.
3. In the Integrate your work modal dialog box, click Pega Agile Studio.
4. In the API URL for Pega Agile Studio field, provide the API URL for your instance of
Agile Studio, and click Connect.
5. Associate your Agile Workbench work items with a product and release by
selecting an existing Agile Studio product and release, or by creating a product
and release.
6. Click Begin integration.
7. Click Done after the integration is complete.
• Agile Workbench
• Integrating Agile Workbench with Jira in Pega Platform from 8.3.x
Creating stories
Speed up your application development by providing your team with specific
information about the features that they design. By implementing stories, you can also
track and manage the workload of your team more effectively.When you create stories,
you define the functional requirements for features, estimate the completion time, and
assign the priority level.
Before you begin:
HTTPS protocol.


3. Optional: To record videos or take screenshots, in the Agile Workbench tool, add
the Pega Screen and Video Capture extension to your browser, by clicking Install
Chrome.
4. In the header of the Agile Workbench tool, click Create work item > Create Story.
5. In the Name field, enter text that summarizes what users can do with the new
functionality.
6. In the Description field, enter text that describes the new functionality to
implement, the key stakeholders to involve, and the relevant business value.
7. In the Associated feature list, select a feature that relates to the story.
8. In the Due field, select a deadline for story resolution.
9. Optional: To speed up story resolution, in the Owner field, assign the story to a
user by entering a user ID.
10. In the Complexity list, select the level of effort to complete the story.
11. In the Priority field, select the relative importance of the story.
During triaging, the development team uses this field to determine when to
implement the story relative to other items in the product backlog.
attachment type:
Choices Actions

Record video.
by clicking Share.

Capture screen.

Choices Actions

screen area that relates to the story.
information about the story, and
then click Capture screen.
want to capture, and then click
Share.

Attach files.

Attach URL.
name for the URL.
select URL.
e. Click Submit.
13. In the Acceptance criteria section, click Add new criteria, and then enter metrics
or constraints that the team must meet before they can resolve the story.
14. Click Save.

For example:
The following figure shows a sample user story in Agile Workbench that
describes requirements for a case type and includes an attachment:

User story

What to do next:
Discuss the story with a development team. For more information, see
• Creating stories in bulk
Creating stories in bulk

Save time during your application development by creating stories in bulk. By
incorporating stories, you provide traceability for the process of delivering an
application and link functional requirements with traceable work items.For example,
you can create a template with of stories that are common to your development
process, and then import the stories from the template, instead of creating similar
stories multiple times. You can also communicate with your stakeholders offline to
prepare a story template, and then conveniently upload the stories into Agile
Workbench.
Before you begin:
Ensure that your application is not integrated with Pega Agile Studio or other
project management applications.
Populating story templates
Automate the creation of stories by populating the columns in a story template with
functional requirements. By implementing stories, you can track, manage, and
communicate development of your projects. For example, you can define which stories
contain features that are essential to your application, so that your development team
can prioritize their work.
1. Download a story template:

a. In the navigation pane of App Studio, click Overview.
b. In the Application profile section, click Manage.

c. In the Application profile header, click Actions > Import stories.

d. In the Import stories window, download a story template .xlsx file to your
local computer by clicking Download the template.
e. Open the file.
2. In the Name column, enter text that summarizes what users can do with the
functionality that the story delivers.
If you enter duplicate names, your application creates stories with the same name
but different IDs.
3. Optional: Add supporting information to the story:

a. In the Description column, enter text that describes the new functionality to
implement, the key stakeholders to involve, and the relevant business value.
b. In the Associated feature ID column, enter the ID of the feature that this
story implements.
For more information about feature IDs, see Finding a feature ID.
Result:
During import, your application promotes features from the built-on

application or previous versions, to the current version of your
application.
c. In the Complexity column, select an option to indicate the level of effort that
is needed to complete the story.
d. In the Priority column, select the importance of the story, relative to other
stories in the product backlog, to indicate appropriate time for the team to
start work on the story.
e. In the Acceptance criteria column, enter specific metrics or constraints to
consider before the team can resolve the story.
f. Optional: To define more than one criterion, press the Alt and Enter keys to
insert a line break in the cell, and then repeat substep 3.e.

4. Optional: To add more stories to the template, repeat steps 2 through 3.

5. Save and close the file, without changing the file format.
Importing story templates
Track and manage development of your application by importing stories into Agile
Workbench. By importing stories into your project you can ensure that your
development team correctly prioritizes work, for example, by focusing on stories with a
high priority.

3. In the Application profile header, click Actions > Import stories.
4. In the Import stories window, select a story template to upload by clicking
Choose File.
5. Upload the story template by navigating to the location of the file, and then
clicking Open.
6. Click Import.
Result:
The stories that you imported are visible in Agile Workbench, in the Stories
tab, as shown in the following figure:

Imported stories
Finding a feature ID
For better traceability of your application development, find the ID of a feature so that
you can reference the ID later in a story or story template. As a result, you can
conveniently link stories with features, and provide more transparent development
process.
Note: Finding a feature ID is optional and available only in Dev Studio. You can
continue your low-code application development in App Studio without finding
a feature ID.
1. In the navigation pane of Dev Studio, click App.

2. Click the Classes tab.

3. In the search field, enter Data-Application-, as shown in the following figure:
Searching application features
4. Click Feature to display a list of features.

5. Optional: To narrow the results, in the Application name column, click the Filter
icon, and then enter the name of your application or a built-on application.
6. Copy the relevant values in the Feature ID column so that you can add the values
to the Associated feature ID column in your story template.
For example:
The following figure shows a list of application features with feature IDs, feature
name, and information about time and user related to the last update of the
feature:

Application features
Exporting stories
For more transparent application development process, export stories from Agile
Workbench into a file. As a result, you can quickly share information with project
stakeholders offline, for example if some stakeholders lack access to Agile Workbench
in a development environment.

3. In the Application profile header, click Actions > Export Stories.
Result:
The system saves an .xlsx to your local machine and in the header of the
Application profile section you can view the name of the newly downloaded file,
as shown in the following figure:

Exported stories
Troubleshooting errors with a story template
When you import your stories in bulk to Agile Workbench, you might encounter errors.
Typically, errors stem from an invalid story template file type or information missing in
the story template.
The template has an invalid file structure or an invalid file type
Import of stories fails because the file that you upload is in a format different
from .xlsx. The Import Stories modal dialog box displays information that no file is
chosen.

3. In the header of the Application profile section, click Actions > Import Stories.
4. In the Import Stories dialog box, click Download the template to save an .xlsx file
to your local machine.
5. Open the file.
6. Copy the information from your original template to the relevant columns in the
file.
7. Save the file but do not change its format.
8. In the Import Stories dialog box, click Choose File.
9. Navigate to the location of your story template, and then click Open to upload the
file.
Stories fail import
When you import stories, the import fails. The Application profile header displays a
message with a number of failed stories, as shown in the following figure:

Failed import message
1. On your local machine, navigate to your story template.

2. Ensure that you provide a value for all stories in the Name column.
3. Save the file but do not change its format.
4. Restart the import.

• Changing statuses of work items
Setting your current work item

To control which work item is associated with rules that you create, edit, or copy, set
your current work item when you start working on a new feature. As a result, your
application development is more transparent and you can more easily communicate to
your team which application elements you currently work on.For example, you can
provide an ID of user story that corresponds with the feature that you start working on.
Note: Setting a current work item is suitable for advanced developers who
implement application elements in Dev Studio. You can continue your low-
code application development in App Studio without setting a current work
item.

1. In the footer of Dev Studio, on the developer toolbar, click Current work, as shown
in the following figure:
Current work item on the developer toolbar
2. In the What are you currently working on field, press the Down arrow key, and
then select the work item that you want to implement.
3. Click Submit.
Result:
If you integrate Agile Workbench with Pega Agile Studio, you can view
development changes on the Related updates tab of a work item.
Changing statuses of work items

Provide status updates for work items, such us user stories, bugs, and feedback items,
to communicate the progress of your application development to other team members.
For example, when your team starts working on a story, a team member can drag the
story from the To do column to the Doing column.


3. In the Application profile work area, click the Feature map tab.
4. In the Work items section, change the status of a work item by dragging the item
to a different column.
5. Optional: To quickly find an item that you want to update, filter the items by type:
a. In the header of the Work items section, click All.
b. In the list, select the checkbox of the type of item that you want to display,
for example, Story.
For example:
The following figure shows multiple work items categorized into To Do, Doing,
and Done columns based on the progress of the application development
process:
Work items

• Agile Workbench

Collaborating with development teams

Improve and accelerate your project delivery by collaborating with development teams
by using Pulse. When you post Pulse messages, you ensure that team members have
up-to-date and relevant information about the features that they implement.You can
post general messages that users see in the Developer collaboration section, or
comment on specific work items, such as stories and bugs in Agile Workbench. You can
also filter, comment on, and like messages.
1. In the header of App Studio, choose the context for your message:
• To post a general message, click the Toggle developer collaboration icon.
• To comment on a work item, such as a user story, a bug, or a feedback item,
click the Toggle developer assistant icon, and then on the Work tab select a
work item that you want to discuss.
2. In the Post text field, enter your message.
3. Optional: To provide more information and context to your message, add an
attachment:
a. Below the text field, click the Add attachment icon.
b. In the dialog box that appears, select a local file that you want to attach.
c. Attach the file to the message by clicking Open.
4. Optional: To emphasize specific information in your message, format your text by
clicking the Formatting help icon, and then copying special characters into the
message.
For example:
You can write a part of your message in bold or italics.
5. Optional: To provide only relevant information to users, make your post visible
only to specific users:
a. Above the text field, click Post > Private message.
b. In the Add users field, enter or select the IDs of the users that you want to be
able to view the post.
By default, everyone in the application can view posts.

6. Click Post.
For example:
The following figure shows a Developer collaboration section with a Pulse

message that includes styling and an attachment:
Developer collaboration section
• Collaborating with users by using Pulse

• Replying to a message in Pulse
Integrating Agile Workbench with Jira in Pega

Platform from 8.3.x
Capture real-time feedback about an application development project directly in the
application with the Agile Workbench tool. By using the Atlassian Jira component that is
available from Marketplace, you can continue to use a real-time Agile methodology and
integrate Agile Workbench with Jira to take advantage of its project management
features, such as project and issue tracking, Scrum and Kanban support, backlog
prioritization, and sprint planning.
Note: Integrating Agile Workbench with an extensively customized version of

Jira might cause issues. Ensure that your customization of Jira supports official
Atlassian Jira APIs. For more information, refer to the list of REST APIs v2 in
Atlassian documentation.
Before you begin:
Prepare for the integrating Agile Workbench with Jira:
• Disconnect any existing integration to a project management system. On

the Integration & security tab of the Application rule form, in the Agile
Workbench integration section, click Configure integration, and then click
Disconnect integration.
• If you use a custom workflow or a custom list of priorities in Jira, ensure
that Jira workflow and priorities match the Agile Workbench configuration.
For more information, see Mappings of Agile Workbench values to Jira
values.
• Check whether your Jira version is complaint with General Data Protection
Regulation (GDPR). For more information, refer to Atlassian documentation.

1. Download the Jira component from the Marketplace.

Definition.
3. On the Definition tab, in the Enabled components section, click Manage
components.
4. Click Install new, select the file that you downloaded from the Marketplace, and
then click Open.
5. Enable this component for your application by selecting the Enabled check box,
and then click OK.
6. In the list of enabled components, verify the Jira component and its version, and
then save the rule form by clicking Save.
7. Update the PM_Jira_AuthProfile Authentication Profile instance with credentials
that you plan to use to access your Jira system through REST authentication:
• Provide the user ID as user name and the API token for password. If your Jira
server does not support API token, use your Jira password.
For more information about Jira API token, refer to the Atlassian
documentation.
• To use a method of authentication other than Basic, delete and re-add the
PM_Jira_AuthProfile instance by using the same name for the new version.
8. In the authentication profile, select the Preemptive authentication check box.
9. In the navigation pane of Dev Studio, click your operator icon, and then click
Preferences.
10. In the Project management section, in the User ID field, enter your Jira details:
• To integrate with Jira version that is GDPR-complaint, enter your Jira account
ID.
• To integrate with Jira version that is GDPR non-complaint, enter your Jira user
ID.
11. Click Save.
12. If your Jira version is GDPR non-compliant, perform additional configurations to
integrate:

a. Expand the SysAdmin category, and then click RuleSet.

b. Click the JiraIntegration ruleset, and then open the
IsAccountIDSupportedByJIRA rule.
c. Click Save > Save as.
For more information about saving rules, see Copying a rule or data
instance.
d. On the Advanced tab of the new rule, set the When rule name to Never, and
then click Save.
e. Perform check-in.
For more information about checking in rules, see Checking in a rule.
Definition.
14. On the Integration & security tab of the Application rule form, in the Agile
Workbench integration section, click Configure integration.
15. Select Jira.
16. Provide the API URL for Jira, and then click Connect.
17. Associate your Agile Workbench work items with a project and release by selecting
an existing Jira project and release, or by creating a project and release.
Result:
All of the user stories and bugs that were created in Agile Workbench are
exported to Jira and associated with the project and release that you
specified. A confirmation message explains the results of the integration
process.
19. Click Done.
Related concepts
• Building your first application

Related tasks

Platform 8.1.x to 8.2.x

Before you begin:

• Check whether your Jira version is complaint with General Data Protection
Regulation (GDPR). For more information refer to Atlassian documentation.

Definition.
components.
then click Open.
and then click OK.
7. Update the PM_Jira_AuthProfile Authentication Profile instance with credentials
that you plan to use to access your Jira system through REST authentication:
• Provide the user ID as user name and the API token for password. If your Jira
server does not support API token, use your Jira password.
For more information about Jira API token, refer to the Atlassian
documentation.
• To use a method of authentication other than Basic, delete and re-add the
PM_Jira_AuthProfile instance by using the same name for the new version.
8. In the authentication profile, select the Preemptive authentication check box.
Preferences.
10. In the Project management section, in the User ID field, enter your Jira details:
• To integrate with Jira version that is GDPR-complaint, enter your Jira account
ID.
• To integrate with Jira version that is GDPR non-complaint, enter your Jira user
ID.
11. Click Save.
12. If your Jira version is GDPR non-compliant, perform additional configurations to
integrate:
a. Expand the SysAdmin category, and then click RuleSet.

b. Click the JiraIntegration ruleset, and then open the

IsAccountIDSupportedByJIRA rule.
c. Click Save > Save as.
For more information about saving rules, see Copying a rule or data
instance.
d. On the Advanced tab of the new rule, set the When rule name to Never, and
then click Save.
e. Perform check-in.
For more information about checking in rules, see Checking in a rule.
Definition.
15. Select Jira.
Result:
process.
19. Click Done.
Related concepts

Related tasks

Platform 7.3.x to 7.4.x

Before you begin:

• Ensure that your Jira version is GDPR non-compliant. For more information,
refer to Atlassian documentation.

Definition.
components.
then click Open.
and then click OK.
7. Update the PM_Jira_AuthProfile Authentication Profile instance and populate it
with the user ID and password that you use to access your Jira system through
REST authentication.
If you want to use a method of authentication other than Basic, delete and re-add
the PM_Jira_AuthProfile instance, using the same name for the new version.
Preferences.
9. In the Project management section, in the User ID field, enter your Jira user ID,
and then click Save.
Definition.
12. Select Jira.

Result:
process.
Related concepts
Related tasks
Defining application behavior

When you define how your application behaves at run time, you provide an experience
that optimally meets the needs of end users and customers. You can also define how
design-time actions correlate to run-time behavior, and how actions that users perform
affect processing in your application.For example, you can define which actions users
need to perform toward the resolution of your business process, and which actions an
application performs automatically.
In App Studio, a low-code environment to create and configure applications, you can
define application behavior in the following areas of your application:
Case types
Build reusable templates for your business processes in a visual and user-friendly way
by placing user actions and application automations in a sequential order. You can
enrich your case processing by implementing various functionalities, such as

notifications about case events, service-level agreements, or optional actions that take
part in processing only under specified circumstances.
For more information about case configuration and processing, see Case management.
Data objects and integrations
Define objects to store data that your application uses while processing work, and then
organize those objects into a logical model. By connecting the objects, you can
conveniently reuse data across your application. For example, you can create an object
that stores contact details of a customer, and then reuse the object in various places of
your application.
For more information about managing data objects, see Data modeling and Creating a
data object.
Channels
Create channels through which run-time users can interact with your application. You
can select among numerous options to meet your unique needs, such as web portals,
mobile channels, and digital messaging. by implementing different means of
communication and interaction, you can expand your application to wider audiences.
For more information about creating and configuring conversational channels, such as
Facebook Messenger, WhatsApp Messenger, or SMS/MMS (Twilio), see Conversational
channels.
For more information about adjusting your application to mobile devices, see Mobile
solutions.
User management
Invite collaborators to your application for more robust project development, manage
personas to organize types of run-time users, and define types of access for different
user types to ensure that both developers and end users interact only with the parts of

your application that are relevant to their role. You can also implement authorization
mechanisms to increase security.
For more information about managing personas, see Adding personas to organize
users.
For more information about low-code security solutions, see Security in App Studio.
User experience
Provide an inclusive, intuitive, and clear user interface so that end users can create and
process work in your application. For low-code and user-friendly application
development experience, Pega Platform™ automatically builds your user interface for
you, for example, when you drop different UI elements.
For more information about user interface, see Traditional UI architecture and
Constellation architecture.
The following figure summarizes main elements that you need to consider when you
define your application behavior:

Application behavior elements
• Differences in naming between App Studio and Dev Studio
Differences in naming between App Studio and Dev

Studio
When you create resources in App Studio, Pega Platform™ creates one or more rules
and potentially classes. Dev Studio provides visibility into all the created records while
App Studio usually exposes only objects with less complex configurations. In some
cases, App Studio and Dev Studio refer to the same resource, but use different terms.
By understanding the differences, you can better understand how Dev Studio stores
the elements of your application that you create in App Studio.
The following table lists App Studio and Dev Studio terms with additional information,
where applicable:

App Studio Dev Studio term Additional information

term
Data object Data type In Dev Studio, you work directly with
data types.
For more information, see Creating a

data object and Creating a data type
in Dev Studio.
Field Property In App Studio, you add fields to data

models and views. The system
creates a corresponding property
that you can modify in Dev Studio.
For more information, see

Configuring a data model for a case.
Landing Harness For more information, see

page Harnesses.
New user New operator ID When you invite users to your

application, Dev Studio creates a
new operator ID and adds it to an
access group based on the
developer role or persona that you
specify when you invite the user.
For more information, see Inviting

collaborators to your application.
People, Operators In App Studio, both “people” and

users “users” refer to the actual end users
of an application.


term
Persona Access group When you create a persona in App

Studio, Dev Studio automatically
creates a corresponding access
group. However, not all access
groups in Dev Studio have
corresponding personas in App
Studio.
For more information, see Learning

about access groups and Managing
access roles.
Single Page property You create data and case references

record data when you create fields. This complex
or case field type uses a Page property to
reference call a data page to source either case
or data references. Page properties
must reference a data type that
defines the structure or the list of
grouped fields.
For more information, see Creating

fields for capturing data.
Multiple Page List property You create data and case references
data or when you create fields. This complex
case field type uses a Page List property
references to call a data page to source either
(list of case or data references. Page List
records) properties must reference a data


term
type that defines the structure or

the list of grouped fields.

Single Page property You create queries when you create

record fields. This complex field type uses a
query Page property to call any desired
data page accessible to your
application to source data.

Multiple Page List property You create queries when you create
queries (list fields. This complex field type uses a
of records) Page List property to call any desired
data page accessible to your
application to source data.

Single Page property You embed data in a case when you

record create fields. This complex field type
embedded uses a Page property without
data referencing any external data
sourcing.


term

Embedding data in a case.
Multiple Page List property You embed data in a case when you
records create fields. This complex field type
embedded uses a Page List property without
data referencing any external data
sourcing.

Embedding data in a case.
Team Work group In App Studio, you create teams in

user interface portals that include
the My Teams widget.
For more information, see Creating a

team.
Work Workbasket Workbasket is a deprecated name

queue for a work queue. You can still
encounter workbasket in Dev
Studio in places such as out-of-the-
box rule names.
For more information, see Defining

work routing settings for an
operator.

Pega Platform 8.8: 7 April 2023

Uploaded by

Document Informationclick to expand document information

Document Informationclick to expand document information

Copyright:

Available Formats

Pega Platform 8.8: 7 April 2023

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pega Platform 8.8: 7 April 2023

Uploaded by

Copyright:

Available Formats

Pega Platform 8.

©2023 Pegasystems Inc

©2023 Pegasystems Inc

Estimating application development. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

©2023 Pegasystems Inc

Get started with Pega Platform

Focus on customer goals

IT and business collaboration

©2023 Pegasystems Inc

development phases include all stakeholders. Additionally, creating granular

©2023 Pegasystems Inc

To learn more about low-code application development and to start building

• Low-code application development and the Pega Express delivery approach

• Creating a Microjourney for customer success

• Designing and tracking Microjourneys development

• Defining application behavior

©2023 Pegasystems Inc

Low-code application development and the

The Pega Express delivery approach

What is the purpose of my application?

©2023 Pegasystems Inc

Hiring a job candidate Reviewing expenses

Collecting personal details Collecting personal details

Reviewing work experience Collecting receipts

Conducting a job interview Reviewing receipts

Approving or rejecting a candidate Approving or rejecting a request

Optional: Running a background check Optional: Applying currency rates

Who is my application for and how do they need to use it?

©2023 Pegasystems Inc

Persona Channel Actions

Job candidate Mobile app

Hiring manager Manager portal

©2023 Pegasystems Inc

Persona Channel Actions

An important aspect of application development is accessibility, so that users who

• A part-time customer service representative (CSR) at a hotel chain has reduced

©2023 Pegasystems Inc

Different perceptions of colors

How does my application source and store data?

During a hiring process, a job candidate provides personal information by

©2023 Pegasystems Inc

Reusing data in a Microjourney

• Collecting information from a customer

©2023 Pegasystems Inc

• A customer who creates a request through a web portal

• Personal details that the customer provides

The following figure summarizes the Microjourney of reviewing a loan request:

©2023 Pegasystems Inc

Microjourney in the Pega Express delivery approach

The following figure shows a sample Microjourney that focuses on reviewing a

©2023 Pegasystems Inc

A Microjourney in App Studio

©2023 Pegasystems Inc

• App Studio overview

App Studio overview

App Studio purpose

For more information, see Adding case types to organize work.