ACP-120 Jira Administration for Cloud Questions and Answers

In Jira Software Cloud, automation rules usesmart valuesto reference issue fields, such as the issue key, in actions like sending emails. The correct syntax for referencing the issue key in theSend Emailaction’s subject line is{{issue.key}}(Option B).

Explanation of the Correct Answer (Option B):

The{{issue.key}}smart value retrieves the issue key (e.g., PROJ-123) of the issue that triggers or is processed by the automation rule. This can be used in the subject line of theSend Emailaction to include the issue key dynamically.

Exact Extract from Documentation:

Use smart values in automation rules

Smart values allow you to access issue fields and other data in automation actions. To reference the issue key:

Use{{issue.key}}to insert the issue key (e.g., PROJ-123) in fields like email subjects or bodies.Examples:

Email subject: Issue {{issue.key}} Updated

Output: Issue PROJ-123 UpdatedNote: Smart values are enclosed in double curly braces ({{}}). Use dotnotation to access fields (e.g., {{issue.key}}, {{issue.summary}}).(Source: Atlassian Support Documentation, "Use smart values in Jira automation")

Why This Fits: The{{issue.key}}syntax is the standard way to reference the issue key in Jira automation, making it the correct choice for theSend Emailaction’s subject line.

Why Other Options Are Incorrect:

{{triggerIssue.issuekey}} (Option A):

The{{triggerIssue}}smart value refers to the issue that triggers the rule, but the field iskey, notissuekey. The correct syntax is{{triggerIssue.key}}, not{{triggerIssue.issuekey}}. Additionally,{{issue.key}}is sufficient for most rules unless specifically targeting the trigger issue in a branched rule.

Extract from Documentation:

Use{{triggerIssue.key}}to reference the key of the issue that triggers the rule.{{issue.key}}is used for the current issue in the rule’s context.

(Source: Atlassian Support Documentation, "Use smart values in Jira automation")

{{issueKey}} (Option C):

Smart values require dot notation for field access (e.g.,{{issue.key}}).{{issueKey}}is not a valid smart value, as it does not reference a specific field.

Extract from Documentation:

Smart values must reference valid fields using dot notation (e.g., {{issue.key}}, {{issue.summary}}). Single variables like {{issueKey}} are not supported.

(Source: Atlassian Support Documentation, "Use smart values in Jira automation")

{issue.issuekey} (Option D):

The syntax uses single curly braces andissuekeyinstead ofkey, which is incorrect. Smart values require double curly braces ({{}}) and the correct field name (key).

Extract from Documentation:

Smart values use double curly braces ({{}}) and standard field names (e.g., {{issue.key}}). Incorrect formats like {issue.issuekey} will not work.

(Source: Atlassian Support Documentation, "Use smart values in Jira automation")

issue.key (Option E):

Without curly braces,issue.keyis treated as plain text, not a smart value. It will not resolve to the issue key and will appear literally in the email subject.

Extract from Documentation:

Smart values must be enclosed in {{}} to be evaluated. Plain text like issue.key will not resolve to a field value.

(Source: Atlassian Support Documentation, "Use smart values in Jira automation")

Additional Notes:

TheSend Emailaction in Jira automation allows smart values in the subject and body to dynamically include issue data.

If the rule involves branching or multiple issues,{{issue.key}}refers to the current issue in the rule’s context, while{{triggerIssue.key}}refers to the triggering issue. For a simple email rule,{{issue.key}}is typically sufficient.

Ahmed is a project administrator in the DEV project, which means he is in theAdministratorsproject role (as per the permission scheme, whereAdminister Projectsis granted to this role). However, he cannot create sprints because he lacks theManage Sprintspermission, which is granted to theatlassian-addons-project-accessandCoreproject roles. To resolve this, Ahmed shouldadd the Administrators project role to the ‘Manage Sprints’ permission(Option D).

Explanation of the Correct Answer (Option D):

TheManage Sprintspermission allows users to create, start, complete, or delete sprints in a project. According to the permission scheme, this permission is granted to theatlassian-addons-project-accessandCoreproject roles, but not to theAdministratorsproject role, which Ahmed belongs to.

As a project administrator, Ahmed has theAdminister Projectspermission, which allows him to modify the project’s permission scheme (viaProject settings > Permissions) and add theAdministratorsproject role to theManage Sprintspermission. This will grant him the ability to create sprints without needing Jira administrator privileges.

Exact Extract from Documentation:

Manage Sprints permission

TheManage Sprintspermission allows users to create, start, complete, or delete sprints in a project. This permission is granted via the project’s permission scheme.

To update permissions:

Go toProject settings > Permissions.

Edit the permission scheme and add a user, group, or project role (e.g., Administrators) to theManage Sprintspermission.Note: Project administrators can modify the permission scheme for their project if they have theAdminister Projectspermission.(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Why This Fits: Adding theAdministratorsproject role to theManage Sprintspermission directly addresses Ahmed’s lack of permission to create sprints, leveraging his existing project administrator privileges.

Why Other Options Are Incorrect:

Add himself to the Core project role (Option A):

Adding himself to theCoreproject role would grant Ahmed theManage Sprintspermission, as this role is listed for that permission. However, as a project administrator, Ahmed can modify the permission scheme directly instead of adding himself to another role, which may grant unnecessary permissions (e.g.,View Development Tools). Option D is more appropriate, as it aligns with his administrative role.

Extract from Documentation:

Project roles are managed inProject settings > People. Adding a user to a role grants all permissions associated with that role, which may include more than needed.

(Source: Atlassian Support Documentation, "Manage project roles")

Add himself to the Sprint Team project role (Option B):

TheSprint Teamproject role is only listed for theView Development Toolspermission, notManage Sprints. Adding himself to this role would not grant Ahmed the ability to create sprints.

Extract from Documentation:

Permissions are granted to specific roles or groups in the permission scheme. Verify the roles assigned to each permission before adding users.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Add the Administrators project role to the ‘View Development Tools’ permission (Option C):

TheView Development Toolspermission allows users to view development-related information (e.g., commits, builds). It is unrelated to creating sprints, so adding theAdministratorsrole to this permission would not help Ahmed.

Extract from Documentation:

TheView Development Toolspermission grants access to development information, not sprint management.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Additional Notes:

Ahmed’s ability to modify the permission scheme depends on hisAdminister Projectspermission, which is confirmed by his role as a project administrator.

Theatlassian-addons-project-accessrole is typically used for system or app-related permissions and is not relevant for Ahmed to modify.

After adding theAdministratorsrole toManage Sprints, Ahmed and other administrators will gain sprint management capabilities.

TheImport Jira Cloudfeature allows migration of data between Jira Cloud sites, including projects, issues, configurations, and attachments. However,deleted issues(Option C) cannot be imported, as they are not included in standard Jira Cloud backups or export data.

Explanation of the Correct Answer (Option C):

Deleted issuesare permanently removed from Jira Cloud and are not included in backups or export files created for migration. TheImport Jira Cloudfeature only imports data that exists in the source site’s backup, which excludes issues that have been deleted.

Exact Extract from Documentation:

Import Jira Cloud data

TheImport Jira Cloudfeature allows migration of data between Jira Cloud sites, including:

Projects (company-managed and team-managed).

Issues, comments, and attachments.

Configurations (e.g., custom fields, workflows, automation rules).Limitations:

Deleted issues are not included in backups or exports and cannot be imported.To import:

Create a backup from the source site inSettings > System > Backup manager.

UseSettings > System > Import Jira Cloudon the target site.Note: Requires Jira administrator permissions and may involve Atlassian support for full migrations.(Source: Atlassian Support Documentation, "Import data to Jira Cloud")

Why This Fits:Deleted issuesare not part of the data exported from the source site, making them impossible to import, so Option C is the correct answer.

Why Other Options Are Incorrect:

Automation rules (Option A):

Automation rulesare included in Jira Cloud backups and can be imported to the target site using theImport Jira Cloudfeature, provided they are compatible with the target site’s configuration.

Extract from Documentation:

Automation rules are included in Jira Cloud backups and can be imported, though some rules may require reconfiguration if dependencies (e.g., custom fields) differ.

(Source: Atlassian Support Documentation, "Import data to Jira Cloud")

Custom fields (Option B):

Custom fieldsare part of the configuration data in a Jira Cloud backup and are imported to the target site. Their contexts and options are preserved during migration.

Extract from Documentation:

Custom fields, including their configurations and contexts, are included in backups and imported to the target site.

(Source: Atlassian Support Documentation, "Import data to Jira Cloud")

Team-managed projects (Option D):

Team-managed projectsare fully supported in Jira Cloud backups and can be imported to the target site, including their issues, configurations, and settings.

Extract from Documentation:

Both company-managed and team-managed projects are included in Jira Cloud backups and can be imported to another site.

(Source: Atlassian Support Documentation, "Import data to Jira Cloud")

Attachments (Option E):

Attachments(media files) are included in Jira Cloud backups and can be imported to the target site, provided the backup includes media data.

Extract from Documentation:

Attachments are included in Jira Cloud backups and imported to the target site if media import is enabled.

(Source: Atlassian Support Documentation, "Import data to Jira Cloud")

Additional Notes:

TheImport Jira Cloudfeature is accessed viaSettings > System > Import Jira Cloudand typically requiresJira administratorprivileges, with possible Atlassian support for full migrations.

Deleted issues are permanently removed and cannot be recovered unless a backup from before deletion is available, but even then, they are not part of standard exports.

Other data (e.g., automation rules, custom fields) may require post-import reconfiguration if there are incompatibilities between sites.

TheAdminister Projectspermission in Jira Software Cloud grants users the ability to manage project settings, such as components, versions, and roles. Among the listed actions,modifying component leads(Option C) requires theAdminister Projectspermission, as it involves updating project-specific configurations.

Explanation of the Correct Answer (Option C):

Modifying component leads involves changing the user assigned as the lead for acomponent inProject settings > Components. This action requires theAdminister Projectspermission, as it is a project administration task.

Exact Extract from Documentation:

Administer Projects permission

TheAdminister Projectspermission allows users to manage project settings, including:

Creating, editing, or deleting components and their leads.

Updating project details, roles, and permissions.

Configuring notification schemes, issue security, and other project-level settings.To modify component leads:

Go toProject settings > Components.

Edit the component and update the lead.Note: Only users withAdminister Projectspermission can perform this action.(Source: Atlassian Support Documentation, "Manage components in Jira Cloud")

Why This Fits: Modifying component leads is a project administration task that directly requires theAdminister Projectspermission, making Option C the correct choice.

Why Other Options Are Incorrect:

Reopen bugs (Option A):

Reopening bugs involves transitioning an issue back to an open status, which requires theTransition Issuespermission and possiblyEdit Issuespermission, depending on the workflow. It does not requireAdminister Projects.

Extract from Documentation:

Transition Issues permission

Allows users to move issues through workflow transitions, such as reopening a bug. This does not requireAdminister Projects.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Assign issues to themselves (Option B):

Assigning issues to oneself requires theAssignable Userpermission (to be eligible as an assignee) and theAssign Issuespermission (to change the assignee). These are not administrative tasks.

Extract from Documentation:

Assign Issues permission

Allows users to assign issues to other users or themselves, provided they have theAssignable Userpermission. This does not requireAdminister Projects.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Edit due dates (Option D):

Editing due dates requires theEdit Issuespermission, as it involves modifying an issue’sDue Datefield. This is not an administrative task.

Extract from Documentation:

Edit Issues permission

Allows users to modify issue fields, such as Due Date, Summary, or Description. This does not requireAdminister Projects.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Set fix versions (Option E):

Setting fix versions requires theEdit Issuespermission to modify theFix Versionsfield. In some cases, theResolve Issuespermission may also be needed if the field is restricted to resolution workflows, butAdminister Projectsis not required.

Extract from Documentation:

Edit Issues permission

Allows users to update fields like Fix Versions. TheAdminister Projectspermission is required to manage versions, not set them on issues.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Additional Notes:

TheAdminister Projectspermission is typically granted to project administrators or leads via the project’s permission scheme. It is checked inProject settings > Permissions.

Other actions listed (A, B, D, E) are issue-level operations that do not require administrative privileges.

To meet the requirements of restricting visibility of some BRAVO issues to managers, others to supervisors, and keeping the remaining issues visible to all users, you need to configure anissue security schemeto define security levels and theSet Issue Securitypermission to allow users to apply these levels. These two elements are critical for implementing issue-level security in a company-managed project.

Explanation of the Correct Answers:

Issue security scheme (Option A):

Anissue security schemedefines security levels that restrict who can view issues based on criteria such as users, groups, or roles. To meet the requirements, you need to create at least three security levels: one for managers, one for supervisors, and one (or none, for default visibility) for all users. The scheme is then applied to the BRAVO project to enforce these visibility rules.

Exact Extract from Documentation:

Configure issue security schemes

Issue security schemes define security levels to restrict who can view issues. Each level specifies users, groups, or roles (e.g., managers, supervisors) who can see issues assigned to that level.

To create a scheme:

Go toSettings > Issues > Issue security schemes.

Create a new scheme and add security levels (e.g., “Managers Only,” “Supervisors Only,” “All Users”).

Assign the scheme to a project inProject settings > Issue security.Note: Security levels override theBrowse Projectspermission for restricted issues.(Source: Atlassian Support Documentation, "Configure issue security schemes")

Why This Fits: The issue security scheme is necessary to create security levels that restrict visibility to managers, supervisors, or all users, addressing all three requirements.

Set Issue Security permission (Option B):

TheSet Issue Securitypermission allows users to select a security level for an issue (via theSecurity Levelfield). Without this permission, users cannot assign issues to the “Managers Only” or “Supervisors Only” security levels,which is necessary to implement the restricted visibility requirements. This permission must be granted to appropriate users (e.g., project admins or specific roles) in the project’s permission scheme.

Exact Extract from Documentation:

Set Issue Security permission

TheSet Issue Securitypermission allows users to set or change the security level of an issue, determining who can view it. This permission is granted via the project’s permission scheme.

To configure:

Go toProject settings > Permissions.

Add users, groups, or roles (e.g., Administrators) to theSet Issue Securitypermission.Note: Without this permission, users cannot assign issues to specific security levels, even if a scheme is configured.(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Why This Fits: TheSet Issue Securitypermission is required to enable users to apply the security levels defined in the issue security scheme, ensuring that issues can be restricted to managers or supervisors as needed.

Why Other Options Are Incorrect:

Global permissions (Option C):

Global permissions (e.g.,Administer Jira,Create Projects) control system-wide actions, not project-specific visibility. Issue visibility is managed by project-level permissions and security schemes, not global permissions.

Extract from Documentation:

Global permissions control system-wide actions, such as administering Jira or sharing filters. Issue visibility is managed by project permissions and issue security schemes.

(Source: Atlassian Support Documentation, "Manage global permissions")

Browse Projects permission (Option D):

TheBrowse Projectspermission allows users to view issues in a project. While all users currently have this permission (since they can see all BRAVO issues), modifying it does not address the need to restrict specific issues to managers or supervisors. Issue security schemes overrideBrowse Projectsfor restricted issues.

Extract from Documentation:

TheBrowse Projectspermission allows users to view issues in a project, but issue security levels can further restrict visibility for specific issues.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Administer Projects permission (Option E):

TheAdminister Projectspermission allows users to manage project settings, such as components or permission schemes. While it may be needed to configure the issue security scheme or permissions, it is not directly required to meet the visibility requirements.

Extract from Documentation:

TheAdminister Projectspermission allows managing project settings but is not required to set issue security levels or view restricted issues.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Additional Notes:

To implement the requirements, create an issue security scheme with three levels:

“Managers Only” (e.g., restricted to a “Managers” group).

“Supervisors Only” (e.g., restricted to a “Supervisors” group).

“All Users” (or no security level, allowingBrowse Projectsto apply).

Assign the scheme to the BRAVO project and grant theSet Issue Securitypermission to users who need to assign these levels (e.g., project admins).

The configuration requires Jira administrator privileges to create the scheme, but project admins can manage security levels within the project.

In a company-managed project, theissue layoutdetermines how fields are displayed in the issue view (e.g., which fields are visible, hidden, or in the context panel). The true statement is thatyou can copy a layout to another project using the same screen(Option B), as Jira allows copying issue layouts to streamline configuration across projects.

Explanation of the Correct Answer (Option B):

Theissue layoutin a company-managed project is configured inProject settings > Issue layoutand is tied to a screen (via the screen scheme). Jira allows copying an issue layout to another project that uses the same screen, ensuring consistent field arrangements across projects.

Exact Extract from Documentation:

Configure issue layouts in company-managed projects

Issue layouts define which fields are displayed, hidden, or placed in the context panel in the issue view.

To copy a layout:

Go toProject settings > Issue layout.

SelectCopy layoutand choose another project that uses the same screen.Note: The target project must use the same screen (via its screen scheme) for the layout to be compatible.(Source: Atlassian Support Documentation, "Configure issue layouts in Jira Cloud")

Why This Fits: Copying an issue layout to another project using the same screen is a supported feature, making Option B the correct answer.

Why Other Options Are Incorrect:

You can reuse fields from a team-managed project (Option A):

Fields in team-managed projects are project-specific and cannot be reused in company-managed projects. Company-managed projects use global custom fields or system fields, managed inSettings > Issues > Custom fields. Fields from team-managed projects are isolated and not accessible.

Extract from Documentation:

Custom fields in team-managed projects are project-specific and cannot be reused in company-managed projects. Company-managed projects use global custom fields.

(Source: Atlassian Support Documentation, "Manage custom fields in Jira Cloud")

You can move any field to the Hidden fields section (Option C):

Not all fields can be moved to theHidden fieldssection. System fields likeSummary,Issue Type, andStatusare required and cannot be hidden. Only non-mandatory fields (e.g., custom fields, non-required system fields) can be hidden.

Extract from Documentation:

In the issue layout, you can hide non-mandatory fields by moving them to theHidden fieldssection. Required fields like Summary, Issue Type, and Status cannot be hidden.

(Source: Atlassian Support Documentation, "Configure issue layouts in Jira Cloud")

You can move any field to the Context fields section (Option D):

TheContext fieldssection (right panel in the issue view) has restrictions on which fields can be placed there. Fields likeSummary,Description, and certain system fields cannot be moved to the context panel, as they are designed for the main issue view. Only eligible fields (e.g., custom fields, Labels, Components) can be moved to theContext fieldssection.

Extract from Documentation:

TheContext fieldssection is for fields like Labels, Components, or custom fields. Core fields like Summary and Description cannot be moved to the context panel.

(Source: Atlassian Support Documentation, "Configure issue layouts in Jira Cloud")

Additional Notes:

Configuring issue layouts requiresproject adminprivileges for the project (Project settings > Issue layout).

Copying layouts is useful for maintaining consistency across projects with similar configurations.

To find issues where Tom set theprioritytoHighestduring the current month, regardless of the current priority value, the JQL query must use theWASoperator to check the historical priority value and theBYclause to specify the user (Tom), along with a time range for the current month. The correct query ispriority was Highest by tom after startOfMonth()(Option B).

Explanation of the Correct Answer (Option B):

The conditionTom set the priority value to “Highest” sometime this monthrequires checking the issue’s change history for thepriorityfield. TheWASoperator checks if a field had a specific value at some point, and theBYclause filters for changes made by a specific user (Tom). Theafter startOfMonth()clause ensures the change occurred within the current month (from the first day of the month to the present).

The conditionthe priority value may or may not be “Highest” nowmeans the query should not filter based on the current priority value, whichOption Bcorrectly avoids by not including a current-state condition (e.g.,priority = Highest).

The querypriority was Highest by tom after startOfMonth()returns issues where Tom changed the priority toHighestafter the start of the current month, satisfying both conditions.

Exact Extract from Documentation:

Advanced searching - operators reference

TheWASoperator checks if a field had a specific value at some point in the issue’s history.

priority was Highest by tom after startOfMonth() returns issues where thepriorityfield was set toHighestby the usertomafter the start of the current month.Note: TheWASoperator does not check the current field value, only historical values. Useafterto specify a time range.(Source: Atlassian Support Documentation, "Advanced searching - operators reference")

Why This Fits: The query usesWASto check historical priority changes by Tom toHighestwithin the current month, without restricting the current priority, making Option B the correct answer.

Why Other Options Are Incorrect:

priority changed to Highest by tom before endOfMonth() (Option A):

TheCHANGEDoperator checks for transitions in field values, butbefore endOfMonth()includes all changes up to the end of the current month, including past months, which is too broad. The query needs to limit changes to the current month (e.g.,after startOfMonth()).

Extract from Documentation:

TheCHANGEDoperator requiresFROMandTOclauses for specific transitions.before endOfMonth()includes all prior changes, not just the current month.

(Source: Atlassian Support Documentation, "Advanced searching - operators reference")

priority was Highest by tom during (startOfMonth(), endOfMonth()) and priority = Highest or priority != Highest (Option C):

Theduring (startOfMonth(), endOfMonth())clause is valid for time ranges, but the additional conditionpriority = Highest or priority != Highestis redundant and always true (it includes all issues). However,duringis less precise thanafter startOfMonth(), as it may exclude changes on the last day of the month depending on timezone handling. This makes the query less optimal.

Extract from Documentation:

Theduringclause defines a time range but may have edge cases with end dates.after startOfMonth()is simpler for current-month filtering.

(Source: Atlassian Support Documentation, "Advanced searching - operators reference")

priority was Highest by tom and (priority = Highest by tom after startOfMonth() or priority != Highest) (Option D):

The clausepriority = Highest by tom after startOfMonth()is invalid, as theBYclause cannot be used with current-state conditions likepriority = Highest. TheWASoperator already covers the historical change, and the additionalor priority != Highestis unnecessary and complicates the query.

Extract from Documentation:

TheBYclause is used withWASorCHANGED, not with current-state conditions likepriority = Highest.

(Source: Atlassian Support Documentation, "Advanced searching - operators reference")

Additional Notes:

The query assumesHighestis a valid priority value (check inSettings > Issues > Priorities).

The query can be tested inIssues > Search for issuesand saved as a filter.

Ensure Tom’s user account is correctly referenced (e.g., username or user ID) and that the user running the query hasBrowse Projectspermission.

The question involves managing versions in a company-managed project in Jira Software Cloud. Maia wants to move all issues from version 1.1 to version 1.2 and remove version 1.1 as an available option in theFix Versionsfield. The two operations that meet both requirements areArchiveandMerge.

Explanation of the Correct Answers:

Archive (Option B):

Archiving a version removes it from theFix Versionsfield as an available option for new issues, while preserving the version’s association with existing issues. Additionally, archiving allows you to move issues to another version (e.g., version 1.2) during the process, meeting both requirements.

Exact Extract from Documentation:

Archive a version

Archiving a version removes it from the list of available versions in fields like Fix Versions, so it can’t be selected for new issues. You can also move issues to another version during the archiving process.

To archive a version:

Go to your project’sReleasespage.

Find the version (e.g., version 1.1) and selectArchive.

Optionally, choose to move issues to another version (e.g., version 1.2).Archived versions are still visible in reports and issue details but are no longer selectable in fields.Note: You need project admin permissions to archive versions.(Source: Atlassian Support Documentation, "Manage versions in company-managed projects")

Why This Fits: Archiving version 1.1 removes it from the Fix Versions field, preventing it from being selected for new issues, and allows Maia to move all issues to version 1.2 during the archiving process, fulfilling both requirements.

Merge (Option D):

Merging a version moves all issues from one version (e.g., version 1.1) to another (e.g., version 1.2) and deletes the source version, effectively removing it from the Fix Versions field. This meets both requirements, as it reassigns issues and eliminates version 1.1 as an available option.

Exact Extract from Documentation:

Merge versions

Merging versions allows you to combine two versions by moving all issues from one version to another. The source version is deleted after the merge.

To merge versions:

Go to your project’sReleasespage.

Find the version to merge (e.g., version 1.1) and selectMerge.

Choose the target version (e.g., version 1.2) to move issues to.After merging, the source version (version 1.1) is removed from the Fix Versions field and is no longer available for selection.Note: Merging is permanent and cannot be undone, so ensure the target version is correct.(Source: Atlassian Support Documentation, "Manage versions in company-managed projects")

Why This Fits: Merging version 1.1 into version 1.2 moves all issues to version 1.2 and deletes version 1.1, ensuring it is no longer an option in the Fix Versions field, thus meeting both requirements.

Why Other Options Are Incorrect:

Delete (Option A):

Deleting a version removes it from the Fix Versions field, but it also removes the version from all issues associated with it without reassigning them to another version. This does not meet the requirement to move issues to version 1.2.

Extract from Documentation:

Delete a version

Deleting a version removes it from the project and clears it from the Fix Versions field of all associated issues. Issues are not reassigned to another version automatically.

Note: Use caution, as this action cannot be undone, and issues lose their version association.

(Source: Atlassian Support Documentation, "Manage versions in company-managed projects")

Build and release (Option C):

Building and releasing a version marks it as complete and moves unresolved issues to another version, but it does not remove the version from the Fix Versions field. Released versions remain selectable unless archived or deleted.

Extract from Documentation:

Release a version

Releasing a version marks it as complete and optionally moves unresolved issues to another version. The released version remains available in the Fix Versions field unless archived.

(Source: Atlassian Support Documentation, "Manage versions in company-managed projects")

Additional Notes:

BothArchiveandMergeare suitable, but they have different implications:

Archiving preserves version 1.1 in reports and issue histories, making it ideal if historical data needs to be retained.

Merging permanently deletes version 1.1, which may be preferred if the version is no longer relevant.

The operations require project admin permissions in a company-managed project, and theReleasespage is accessed viaProject Settings > Releases.

The inability to choose theDelete Issuesbulk action on the Bulk Operation screen indicates that Taylor lacks the necessary permission to delete issues in the project. TheDelete Issuespermission, which is a project-level permission defined in the project’s permission scheme, is required for this action. Therefore, Taylor definitely needsproject permissions(Option D).

Explanation of the Correct Answer (Option D):

TheDelete Issuespermission allows users to delete issues, including via bulk operations. This permission is granted through the project’s permission scheme and is specific to the project containing the issues. If Taylor cannot select theDelete Issuesbulk action, she lacks this permission for the project.

Exact Extract from Documentation:

Delete Issues permission

TheDelete Issuespermission allows users to delete issues, either individually or via bulk operations. This permission is granted via the project’s permission scheme.

To perform bulk operations:

Run a filter to select issues.

On the Bulk Operation screen, choose an action (e.g., Delete Issues).Note: Users must have the relevant permission (e.g.,Delete Issues) for allselected issues to see the action in the bulk operation wizard.To check permissions:

Go toProject settings > Permissions.

Verify which users, groups, or roles have theDelete Issuespermission.(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Why This Fits: TheDelete Issuespermission is a project-level permission, and granting it to Taylor will enable her to choose theDelete Issuesbulk action, makingproject permissions(Option D) the correct answer.

Why Other Options Are Incorrect:

Organization admin privileges (Option A):

Organization admins manage Atlassian organization settings, such as user access and billing. They do not directly control project-level permissions likeDelete Issues.

Extract from Documentation:

Organization admins manage user access and organization settings. Project-specific actions, like deleting issues, are controlled by project permissions.

(Source: Atlassian Support Documentation, "Manage your Atlassian organization")

Jira administration privileges (Option B):

Jira administrators manage global settings, such as schemes and user management. While they can modify permission schemes, theDelete Issuespermission is project-specific and does not require Jira admin privileges to grant or use.

Extract from Documentation:

Jira administrators can modify permission schemes, but theDelete Issuespermission is applied at the project level and does not require admin privileges to use.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Global permissions (Option C):

Global permissions (e.g.,Administer Jira,Create Projects) control system-wide actions, not project-specific actions like deleting issues. TheDelete Issuespermission is project-level, not global.

Extract from Documentation:

Global permissions control system-wide actions, such as administering Jira or sharing filters. Project permissions, likeDelete Issues, are specific to projects.

(Source: Atlassian Support Documentation, "Manage global permissions")

Project administration privileges (Option E):

Project administration privileges (via theAdminister Projectspermission) allow users to manage project settings, such as components and permission schemes. However, deleting issues is an issue-level action that requires theDelete Issuespermission, not administrative privileges.

Extract from Documentation:

TheAdminister Projectspermission allows managing project settings. Deleting issues requires theDelete Issuespermission, which is separate.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Additional Notes:

To resolve the issue, check Taylor’s permissions inProject settings > Permissionsand ensure she has theDelete Issuespermission, either directly, via a group, or via a project role.

If the issues in the bulk operation span multiple projects, Taylor needs theDelete Issuespermission for all relevant projects.

In a team-managed project in Jira Software Cloud, notifications can be configured to alert specific users or roles when certain events occur, such as a change to a custom field. The question specifies a custom field called "Reviewer" with a field type of People, and asks who can be notified when this field changes. Based on Jira Cloud documentation for team-managed projects, the Reviewer (the user selected in the People field) can be notified (Option A).

Explanation of the Correct Answer (Option A):

In team-managed projects, notification schemes are simplified compared to company-managed projects. Project admins can configure notifications for specific events, such as changes to fields, through the Notifications settings in the project.

For a custom field of type People (e.g., "Reviewer"), Jira allows notifications to be sent to the user selected in that field when the field’s value changes. This is because the People field type stores a reference to a Jira user, and Jira’s notification system can dynamically resolve this user for notifications.

Exact Extract from Documentation:

Create and configure notifications in team-managed projects

In team-managed projects, you can set up notifications to inform specific people or roles about issue activity, like when an issue is updated or a field changes.

To configure notifications:

From your project’s sidebar, select Project settings > Notifications.

Select Add notification.

Choose an event, such as Issue updated or Field changed.

Select who to notify, such as:

A specific role, like Assignee or Reporter.

A user selected in a People field (e.g., a custom field like Reviewer).

Other options like watchers or specific users, depending on the event.

Note: Notifications in team-managed projects are simpler and don’t rely on notification schemes or custom events like company-managed projects.

(Source: Atlassian Support Documentation, "Configure notifications in team-managed projects")

Why This Fits: The documentation confirms that a user selected in a People field (such as the "Reviewer" field) can be notified when that field changes. This makes Reviewer the correct choice, as it directly corresponds to the user selected in the custom field.

Why Other Options Are Incorrect:

Current User (Option B):

The Current User refers to the user who performs the action (e.g., the person who changes the Reviewer field). While it’s possible to notify the Current User for some events in team-managed projects, the question asks specifically about notifying someone when the Reviewer field changes, and the most relevant recipient is the user selected in the Reviewer field, not the person making the change.

Extract from Documentation:

Notify the current user

You can choose to notify the user who triggers the event, like the person who updates an issue. This is available for most events in team-managed projects.

(Source: Atlassian Support Documentation, "Configure notifications in team-managed projects")

Single specified email address (Option C):

Team-managed projects do not support sending notifications to a single specified email address that is not associated with a Jira user account. Notifications must be sent to users or roles within the Jira system (e.g., Assignee, Reporter, or a user in a People field).

Extract from Documentation:

Notifications in team-managed projects are sent to users or roles associated with the issue, such as the assignee, reporter, or a user in a custom field. External email addresses are not supported.

(Source: Atlassian Support Documentation, "Configure notifications in team-managed projects")

Single selected user (Option D):

While team-managed projects allow notifications to be sent to a specific user (e.g., a hardcoded user selected during notification configuration), this is not dynamic and does not align with the question’s focus on the Reviewer field changing. Notifying a single selected user would mean the same user is notified every time, regardless of who is set as the Reviewer, which is less relevant than notifying the actual Reviewer.

Extract from Documentation:

You can choose a specific user to notify, but this is a static selection and not tied to dynamic field values like a People field.

(Source: Atlassian Support Documentation, "Configure notifications in team-managed projects")

Group (Option E):

Team-managed projects do not support sending notifications to entire groups of users. Notifications are limited to individual users, roles, or users selected in fields like People fields. This restriction simplifies the notification system in team-managed projects compared to company-managed projects.

Extract from Documentation:

Unlike company-managed projects, team-managed projects don’t support notifying groups or project roles. Notifications are limited to individual users, roles like Assignee, or users in People fields.

(Source: Atlassian Support Documentation, "Configure notifications in team-managed projects")

Additional Notes:

The People field type in Jira is specifically designed to store a single user (or multiple users, depending on configuration), and it integrates with the notification system to allow dynamic notifications based on the selected user(s).

In team-managed projects, the notification configuration is more user-friendly and does not require complex setups like custom events or notification schemes, which are exclusive to company-managed projects.

The question’s focus on the Reviewer field changing makes the user in that field (the Reviewer) the most logical recipient of the notification.

Adding a new issue type to a company-managed project requires updating configurations that map issue types to various settings (e.g., screens, workflows, fields). The configuration item that isdefinitely not impactedis theissue security scheme(Option C), as it controls issue visibility and is not directly tied to issue types.

Explanation of the Correct Answer (Option C):

Anissue security schemedefines security levels that restrict which users can view issues in a project, based on criteria like users, groups, or roles. It is applied at the project level and is not specific to issue types. Adding a new issue type does not require changes to the issue security scheme, as security levels apply to all issues in the project regardless of their type.

Exact Extract from Documentation:

Configure issue security schemes

Issue security schemes define security levels to control who can view issues in a project.

Impact of issue types:

Security levels are applied to all issues in a project, regardless of issue type.

Adding a new issue type does not affect the issue security scheme.To check:

Go toProject settings > Issue security.

Review the security levels and their criteria.Note: Issue security is independent of issue type configurations.(Source: Atlassian Support Documentation, "Configure issue security schemes")

Why This Fits: Theissue security schemeis not impacted by adding a new issue type, as it operates at the project level and does not depend on issue type configurations, making Option C the correct answer.

Why Other Options Are Incorrect:

Issue layout (Option A):

Theissue layoutdefines which fields are displayed or hidden in the issue view for each issue type. Adding a new issue type may require configuring a new issue layout to specify field visibility for that type, impacting this configuration.

Extract from Documentation:

Issue layouts are configured per issue type inProject settings > Issue layout. Adding a new issue type may require a new layout configuration.

(Source: Atlassian Support Documentation, "Configure issue layouts in Jira Cloud")

Issue type screen scheme (Option B):

Theissue type screen schememaps screens to issue types for operations (Create, Edit, View). Adding a new issue type requires assigning a screen to it in the scheme, impacting this configuration.

Extract from Documentation:

Adding a new issue type requires updating the issue type screen scheme to assign screens for the new type.

(Source: Atlassian Support Documentation, "Configure screen schemes in Jira Cloud")

Workflow scheme (Option D):

Theworkflow schememaps workflows to issue types. Adding a new issue type requires assigning a workflow to it in the scheme, impacting this configuration.

Extract from Documentation:

Adding a new issue type requires updating the workflow scheme to assign a workflow for the new type.

(Source: Atlassian Support Documentation, "Configure workflow schemes")

Field configuration scheme (Option E):

Thefield configuration schememaps field configurations to issue types, defining field behavior (required, optional, hidden). Adding a new issue type may require assigning a field configuration to it, impacting this configuration.

Extract from Documentation:

Adding a new issue type may require updating the field configuration scheme to assign a configuration for the new type.

(Source: Atlassian Support Documentation, "Configure field settings")

Additional Notes:

Steps to add a new issue type:

Add the issue type to the project’s issue type scheme inProject settings > Issue types.

Update theissue type screen scheme,workflow scheme, andfield configuration schemeto include the new issue type.

Configure theissue layoutfor the new issue type if needed.

These changes requireJira administratorprivileges for schemes andproject adminprivileges for issue layout.

Theissue security schemeremains unaffected, as it applies to all issues in the project.

To address the requirement of notifying a limited set of users when issues transition to a "Pending" status in a company-managed project, and allowing the project admin to manage the list of users, two key configurations are necessary: aproject roleand acustom event. Below is the detailed explanation based on official Jira Software Cloud documentation.

Project Role (Option A):

Purpose: Project roles allow project administrators to define and manage a group of users who can be assigned specific permissions or notification responsibilities within a project. This is critical for the requirement that the project admin must manage the list of users to be notified.

How It Works: In Jira, project roles (e.g., "Developers," "Administrators," or a custom role like "Pending Status Notifiers") are created and managed at the project level. The project admin can add or remove users from these roles without needing global admin permissions, which aligns with the requirement for the project admin to manage the user list.

Configuration Steps:

Navigate toProject Settings > Peoplein the company-managed project.

Create a new project role or use an existing one (e.g., "Pending Notifiers").

Add users to this role as needed. The project admin can update this list at any time.

In the notification scheme, associate the project role with the custom event (explained below) to ensure that users in this role receive notifications when the event is triggered.

Why This Is Necessary: Using a project role ensures scalability and flexibility. Instead of hardcoding individual users or groups in the notification scheme, a project role allows the admin to dynamically manage who receives notifications without modifying the underlying configuration.

Custom Event (Option C):

Purpose: A custom event is required to trigger notifications specifically for thetransition to the "Pending" status. Jira’s notification system relies on events to determine when and to whom notifications are sent. By creating a custom event, you can link it to the specific workflow transition (e.g., moving to "Pending") and configure the notification scheme to notify the project role.

How It Works: In Jira, events are fired during workflow transitions via post functions. A custom event (e.g., "Issue Moved to Pending") can be created and associated with the transition to the "Pending" status. The notification scheme is then configured to send notifications to the designated project role when this event occurs.

Configuration Steps:

Navigate toSettings > System > Events(requires Jira admin permissions).

Create a new custom event, such as "Issue Moved to Pending," with a description and an appropriate notification template (e.g., "Issue Updated").

In the workflow used by the project, edit the transition to the "Pending" status:

Add a post function to the transition, such as"Fire a Generic Event"or a custom event, and select the custom event ("Issue Moved to Pending").

Update the project’snotification scheme(found inProject Settings > NotificationsorSettings > Issues > Notification Schemes):

Map the custom event to the project role (e.g., "Pending Notifiers") to ensure that users in this role receive notifications when the event is fired.

Why This Is Necessary: A custom event is essential because Jira’s default events (e.g., "Issue Updated," "Issue Created") may not be specific enough to target only the "Pending" status transition. A custom event ensures that notifications are sent only when the issue transitions to "Pending," meeting the requirement for targeted notifications.

Why Other Options Are Incorrect:

Workflow Condition (Option B):

A workflow condition controls whether a user can execute a transition (e.g., restricting who can move an issue to "Pending"). It does not influence notifications or manage lists of users to be notified. Therefore, it is irrelevant to the requirement of notifying users and allowing the project admin to manage the user list.

Workflow Validator (Option D):

A workflow validator checks whether certain criteria are met before allowing a transition to proceed (e.g., ensuring a field is filled). Like conditions, validators do not handle notifications or user management for notifications, making this option incorrect.

Group (Option E):

While groups can be used in notification schemes to define who receives notifications, they are managed by Jira admins at the global level (viaSettings > User Management > Groups), not by project admins. The requirement specifies that theproject adminmust manage the list of users, which is not feasible with groups since project admins lack permission to edit global groups. Project roles, however, can be managed by project admins, making them the correct choice over groups.

Additional Notes:

The configuration assumes a company-managed project, as team-managed projects have simpler permission and notification settings that do not support custom events or complex workflow configurations to the same extent.

If the project admin lacks permission to edit workflows or notification schemes (which require Jira admin access), they would need to collaborate with a Jira admin to set up the custom event and initial notification scheme. However, once configured, the project admin can manage the project role’s membership independently.

The use of a custom event ensures that notifications are specific to the "Pending" status transition, avoiding unnecessary notifications for other transitions or actions.

The question pertains to configuring a"Create a new issue or add a comment to an existing issue" mail handlerin Jira Software Cloud. Mail handlers process incoming emails to create issues or add comments, and certain fields can be specifically configured to control how the handler behaves. According to Jira Cloud documentation, the two fields with specific settings in this type of mail handler areReporterandPriority.

Explanation of the Correct Answers:

Reporter (Option C):

TheReporterfield specifies the user who is set as the reporter of the issue created by the mail handler. In the mail handler configuration, you can define whether the reporter is set to a default user, derived from the email’s "From" address (if the email address matches a Jira user), or another specified user.

Exact Extract from Documentation:

Configuring an email handler

When setting up a mail handler like "Create a new issue or add a comment to an existing issue," you can configure the following settings:

Reporter: Specify the user who will be set as the reporter for new issues. Options include:

The user associated with the email’s "From" address (if they have a Jira account).

A default user (e.g., a project lead or a specific user account).

If no valid user is found, the handler can be configured to reject the email or use a fallback user.This setting ensures that the issue is attributed to the correct user as the reporter.(Source: Atlassian Support Documentation, "Configure email handlers in Jira Cloud")

Why This Fits: The Reporter field is a critical setting in the mail handler, as it determines who is recorded as creating the issue, which affects permissions, notifications, and reporting.

Priority (Option D):

ThePriorityfield allows you to set a default priority for issues created by the mail handler if the email does not explicitly specify a priority. This ensures that new issues have a consistent priority unless overridden by the email content.

Exact Extract from Documentation:

Field settings for mail handlers

For the "Create a new issue or add a comment to an existing issue" handler, you can specify default values for certain fields, including:

Priority: Set a default priority for new issues (e.g., Medium, High). If the email contains a specific priority value (e.g., via a keyword or mapping), it can override the default.These settings allow you to control the behavior of issue creation and ensure consistency in field values.(Source: Atlassian Support Documentation, "Configure email handlers in Jira Cloud")

Why This Fits: The Priority field is explicitly configurable in the mail handler to ensure that new issues are assigned an appropriate priority, making it one of the two fields with specific settings.

Why Other Options Are Incorrect:

Epic Link (Option A):

TheEpic Linkfield is not specifically configurable in the mail handler settings. While you can map email content to fields like Epic Link using advanced configurations (e.g., regex or scripting in Automation), it is not a standard field with specific settings in the mail handler configuration interface.

Extract from Documentation:

Mail handlers allow mapping of email content to standard fields like Summary, Description, or Priority. Advanced field mappings, such as Epic Link, require custom automation rules or third-party apps.

(Source: Atlassian Support Documentation, "Automate email processing with Jira Automation")

Custom Field (Option B):

While custom fields can sometimes be populated via email content (e.g., through regex or automation), the mail handler’s standard configuration does not provide specific settings for custom fields. The handler focuses on system fields like Reporter and Priority.

Extract from Documentation:

Custom fields are not directly supported in the default mail handler settings. To populate custom fields, you may need to use Jira Automation or a third-party mail handler app.

(Source: Atlassian Support Documentation, "Configure email handlers in Jira Cloud")

Watchers (Option E):

TheWatchersfield is not a configurable setting in the mail handler. You cannot specify default watchers or automatically add watchers based on email content in the standard mail handler configuration. Watchers are typically managed manually or via automation rules.

Extract from Documentation:

Watchers are not a configurable field in mail handlers. To add watchers automatically, use JiraAutomation or a workflow post function.

(Source: Atlassian Support Documentation, "Configure notifications and watchers")

Additional Notes:

The"Create a new issue or add a comment to an existing issue" mail handleris one of several mail handler types in Jira Cloud. Its configuration focuses on ensuring that issues are created with the correct metadata (e.g., Reporter, Priority) and that comments are added to existing issues based on issue keys in the email subject.

Configuring the Reporter and Priority fields ensures that issues created via email align with project workflows and notification schemes.

When moving stories from a company-managed project to a team-managed project using a bulk operation, certain issue attributes are preserved, while others may change or be lost due to differences in project configurations. The definite outcome is thattheir comments will remain the same(Option A), as comments are retained during issue moves.

Explanation of the Correct Answer (Option A):

Commentsare part of an issue’s data and are preserved when moving issues between projects, whether from a company-managed to a team-managed project or vice versa. The bulk move operation retains all comments attached to the stories, ensuring they remain visible in the target team-managed project.

Exact Extract from Documentation:

Move issues in Jira Cloud

When moving issues between projects:

Comments: All comments are retained, including their content, author, and timestamps.To move issues:

Select issues and chooseBulk change>Move issues.

Choose the target project and issue type.

Map fields and statuses as needed.Note: Comments are preserved regardless of the source or target project type (company-managed or team-managed).(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Why This Fits: The bulk move operation ensures that comments are transferred with the stories, makingtheir comments will remain the samea definite outcome.

Why Other Options Are Incorrect:

Their keys will remain the same (Option B):

Issuekeys(e.g., PROJ-123) are project-specific, consisting of the project key and an issue number. When moving issues to a different project (from a company-managed to a team-managed project), the issues are assigned new keys based on the target project’s key (e.g., NEWPROJ-456). The original keys do not remain the same.

Extract from Documentation:

When moving issues to a different project, the issue keys change to reflect the target project’s key. The original key is preserved in the issue history as a reference.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Their issue links will be lost (Option C):

Issue links(e.g., “blocks,” “is related to”) are generally preserved during a move, provided the linked issues remain accessible in the target project and the link types are supported. While there could be rare cases where links to restricted issues are affected, it is not a definite outcome that links will be lost.

Extract from Documentation:

Issue links are retained during a move unless the linked issues are inaccessible in the target project due to permissions or restrictions.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Their issue history will be lost (Option D):

Theissue history(e.g., status changes, field updates) is preserved during a move. The history is transferred to the target project, maintaining a record of all changes, including those from the source project.

Extract from Documentation:

The issue history, including all changes and updates, is retained when moving issues between projects.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Additional Notes:

Steps for the bulk move:

Run a filter to select the stories inIssues > Search for issues.

ChooseBulk change > Move issues.

Select the team-managed project and map statuses or fields as needed.

The operation requires theMove Issuespermission in the source project andCreate Issuespermission in the target project.

Other attributes (e.g.,status,custom fields) may need mapping due to differences between company-managed and team-managed projects, but comments are always preserved.

To create projects in Jira Software Cloud without having full Jira administrator privileges, George needs a specificglobal permission, namely theCreate Projectspermission. This permission allows users to create new projects without granting them broader administrative access.

Explanation of the Correct Answer (Option D):

TheCreate Projectsglobal permission enables a user to create new projects in Jira. This permission is distinct from Jira administrator privileges, which include managing global settings like schemes, users, and workflows. By granting George this permission, he can create projects while maintaining a limited scope of authority.

Exact Extract from Documentation:

Global permissions

Global permissions control access to system-wide actions in Jira. TheCreate Projectspermissionallows users to create new projects without requiring full Jira administrator privileges.

To grant this permission:

Go toSettings > System > Global permissions.

Add a user, group, or role to theCreate Projectspermission.Note: Users with this permission can create projects but cannot modify global configurations like schemes or user management unless they have additional permissions.(Source: Atlassian Support Documentation, "Manage global permissions")

Why This Fits: TheCreate Projectsglobal permission directly addresses the requirement for George to create projects without needing Jira administrator privileges, making Option D the correct choice.

Why Other Options Are Incorrect:

Project role (Option A):

Project roles (e.g., Administrator, Developer) are used within a project’s permission scheme to grant project-specific permissions, such asAdminister ProjectsorBrowse Projects. They do not control the ability to create new projects, which is a system-level action.

Extract from Documentation:

Project roles are used in permission schemes to grant permissions within a specific project. They do not apply to global actions like creating projects.

(Source: Atlassian Support Documentation, "Manage project roles")

Product access (Option B):

Product access determines whether a user can use Jira Software or other Atlassian products. While George needs product access to use Jira, this does not grant the specific ability to create projects.

Extract from Documentation:

Product access allows users to log in and use Jira products. Specific actions, like creating projects, require global or project permissions.

(Source: Atlassian Support Documentation, "Manage product access")

Project permission (Option C):

Project permissions (e.g.,Administer Projects,Browse Projects) are defined in a project’s permission scheme and apply to actions within a specific project. Creating a project is a global action, not tied to any existing project’s permission scheme.

Extract from Documentation:

Project permissions control actions within a project, such as editing issues or managing components. Global permissions control system-wide actions like creating projects.

(Source: Atlassian Support Documentation, "Manage project permissions")

Product role (Option E):

Product roles (e.g., Jira Software User, Jira Service Management Agent) define access to specific Atlassian products but do not grant permissions for actions like creating projects. This is not relevant to the requirement.

Extract from Documentation:

Product roles determine access to Atlassian products and are not related to specific permissions like creating projects.

(Source: Atlassian Support Documentation, "Manage product roles")

Additional Notes:

TheCreate Projectspermission can be granted to George via a group or directly to his user account inSettings > System > Global permissions.

As a project lead, George likely already has project-level permissions (e.g.,Administer Projectsfor his projects), but these do not extend to creating new projects.

In a company-managed project, a single workflow can be shared across multiple issue types (e.g., Blogs and Ideas) via aworkflow schemethat maps workflows to issue types. To satisfy a requirement that necessitates a second workflow, the requirement must involve workflow-specific differences that cannot be handled within a single workflow. The requirement thatBlogs should allow reopening after they are closed, but not Ideas(Option D) requires a second workflow, as reopening involves a transition that must be present for Blogs but absent for Ideas.

Explanation of the Correct Answer (Option D):

The requirement to allowBlogsto be reopened after being closed, but notIdeas, means the workflow for Blogs must include a transition from theClosedstatus to an open status (e.g.,OpenorReopened), while the workflow for Ideas must not include this transition. In a single workflow, transitions apply to all issue types using that workflow, so it is impossible to have a transition for Blogs but not Ideas. Therefore, a second workflow is needed: one for Blogs (with a reopen transition) and one for Ideas (without a reopen transition). These workflows can be assigned to the respective issue types via the project’sworkflow scheme.

Exact Extract from Documentation:

Configure workflows in company-managed projects

Workflows define statuses and transitions for issues. A workflow scheme maps workflows to issue types in a project.

To use different workflows for different issue types:

Create separate workflows (e.g., one for Blogs with a reopen transition, one for Ideas without).

Go toSettings > Issues > Workflow schemes.

Edit the project’s workflow scheme to assign the appropriate workflow to each issue type (e.g., Blogs to Workflow A, Ideas to Workflow B).Note: A single workflow applies the same transitions to all issue types it governs. To have different transitions (e.g., reopening for Blogs but not Ideas), use separate workflows.(Source: Atlassian Support Documentation, "Configure workflow schemes")

Why This Fits: The need for a reopen transition for Blogs but not Ideas requires distinct workflows, as a single workflow cannot differentiate transitions by issue type, making Option D the correct answer.

Why Other Options Are Incorrect:

Blogs should be auto-closed after 3 days, but not Ideas (Option A):

Auto-closing issues after 3 days can be achieved using aJira automation rule(e.g., a scheduled rule that transitions Blogs toClosedbased on a time condition). This does not require a workflow change, as the transition toClosedcan exist in a shared workflow, and the automation rule can filter by issue type (Blogs).

Extract from Documentation:

Use Jira automation to transition issues based on time conditions (e.g., close Blogs after 3 days). Filter by issue type to exclude Ideas. This does not require separate workflows.

(Source: Atlassian Support Documentation, "Automate your Jira Cloud instance")

Blogs should be editable after they are closed, but not Ideas (Option B):

Editability after closing is controlled by theEdit Issuespermission and workflow properties (e.g., jira.issue.editable). A workflow property can be set on theClosedstatus to allow editing for Blogs but not Ideas, or a separatefield configuration schemecan make fields read-only for Ideas. This can be managed without a second workflow.

Extract from Documentation:

Use workflow properties (e.g., jira.issue.editable=true) or field configuration schemes to control editability by issue type. Separate workflows are not required.

(Source: Atlassian Support Documentation, "Configure advanced work item workflows")

Blogs should be sent to the project lead each Friday, but not Ideas (Option C):

Sending issues to the project lead each Friday can be handled with aJira automation rule(e.g., a scheduled rule that sends an email or creates a task for Blogs). This is independent of the workflow, as it involves notifications or actions, not status transitions.

Extract from Documentation:

Use Jira automation to send notifications or tasks for specific issue types (e.g., Blogs) on a schedule (e.g., every Friday). This does not require workflow changes.

(Source: Atlassian Support Documentation, "Automate your Jira Cloud instance")

Additional Notes:

Creating a second workflow requiresJira administratorprivileges to modify workflows (Settings > Issues > Workflows) and update the workflow scheme (Project settings > Workflows).

The workflow scheme can assign different workflows to Blogs and Ideas, ensuring the reopen transition is only available for Blogs.

Options A, B, and C can be addressed with automation or other configurations, but Option D fundamentally requires distinct workflows due to the transition difference.

In a company-managed project with issue-level security configured, theSecurity Leveldropdown field allows users to set the security level for an issue, restricting who can view it. If Andre only sees one security level instead of both, the most likely reason is that he lacks theSet Issue Securitypermission (Option C), which is required to view and select security levels in the dropdown.

Explanation of the Correct Answer (Option C):

TheSet Issue Securitypermission allows users to set or change the security level of an issue. Without this permission, a user may not see all available security levels in theSecurity Leveldropdown, or the field may be hidden or restricted. If Andre lacks this permission, he might only see the default security level (if set) or no options at all, depending on the configuration.

Exact Extract from Documentation:

Set Issue Security permission

TheSet Issue Securitypermission allows users to set or change the security level of an issue, which determines who can view it. Without this permission, users cannot modify theSecurity Levelfield or may only see a subset of available levels.

To check this permission:

Go toProject settings > Permissions.

Verify which users, groups, or roles have theSet Issue Securitypermission.Note: The visibility of security levels in the dropdown also depends on the user’s membership in groups or roles defined in the security levels.(Source: Atlassian Support Documentation, "Configure issue security schemes")

Why This Fits: TheSet Issue Securitypermission is directly responsible for allowing users to interact with theSecurity Levelfield. If Andre lacks this permission, he may not see both security levels, making Option C a likely reason.

Why Other Options Are Incorrect:

The other level is configured for different issue types (Option A):

Issue security levels are not tied to specific issue types; they apply to all issues in a project under the issue security scheme. The configuration of security levels is project-wide, so this is not a valid reason.

Extract from Documentation:

Issue security levels apply to all issue types in a project using the same issue security scheme. They are not restricted by issue type.

(Source: Atlassian Support Documentation, "Configure issue security schemes")

Andre is not in a group or project role (Option B):

While security levels may restrict visibility based on groups or project roles, the question is about Andre’s ability to see security levels in the dropdown, not about viewing issues. TheSet Issue Securitypermission determines whether Andre can see and select levels, not his membership in groups or roles for visibility purposes.

Extract from Documentation:

Security levels define who can view issues (e.g., users in a group or role). TheSet Issue Securitypermission controls who can set the level, not who can view the issue.

(Source: Atlassian Support Documentation, "Configure issue security schemes")

The other level is marked as the default (Option D):

Marking a security level as the default ensures it is automatically applied to new issues if no level is specified. However, this does not prevent other levels from appearing in theSecurity Leveldropdown for users with theSet Issue Securitypermission.

Extract from Documentation:

The default security level is applied to new issues if no level is set. All available levels are shown in theSecurity Leveldropdown to users with theSet Issue Securitypermission.

(Source: Atlassian Support Documentation, "Configure issue security schemes")

Andre does not have Edit Issues permission (Option E):

TheEdit Issuespermission allows users to modify issue fields, but theSecurity Levelfield is specifically controlled by theSet Issue Securitypermission. A user can haveEdit Issuespermission but still not see security levels if they lackSet Issue Security.

Extract from Documentation:

TheSet Issue Securitypermission is separate fromEdit Issuesand specifically controls access to theSecurity Levelfield.

(Source: Atlassian Support Documentation, "Manage permissions in Jira Cloud")

Additional Notes:

Another possible reason (not listed) could be that Andre is not in the groups or roles defined for the second security level, limiting its visibility in the dropdown. However, theSet Issue Securitypermission is the most direct cause listed.

To resolve the issue, check Andre’s permissions inProject settings > Permissionsand ensure he hasSet Issue Security.

To create an automation rule that triggers when a Story is updated, checks if it is unestimated (i.e., has no Story Points), and comments on its Sub-tasks, the rule requires aBranch rule on Sub-tasksto target the Sub-tasks and anIssue fields condition on whether Story Points is emptyto check the unestimated status. These two elements are essential to meet the rule’s requirements.

Explanation of the Correct Answers:

Branch rule on Sub-tasks (Option A):

The rule needs to comment on the Sub-tasks of the updated Story. ABranch ruleis used in Jira automation to perform actions on related issues, such as Sub-tasks. TheBranch rule on Sub-tasksallows the rule to iterate over each Sub-task of the Story and execute the comment action.

Exact Extract from Documentation:

Branch rule / related issues

A branch rule allows actions to be performed on issues related to the trigger issue, such as Sub-tasks, Epics, or linked issues.

To comment on Sub-tasks:

Add aBranch rule / related issuescomponent.

SelectSub-tasksas the related issue type.

Add aComment on issueaction within the branch to comment on each Sub-task.Note: The branch rule processes each related issue individually.(Source: Atlassian Support Documentation, "Jira automation actions")

Why This Fits: TheBranch rule on Sub-tasksis necessary to target the Sub-tasks of the Story and apply the comment action, satisfying the requirement to comment on Sub-tasks.

Issue fields condition on whether Story Points is empty (Option B):

The rule must check if the Story is unestimated, meaning theStory Pointsfield is empty (null or not set). TheIssue fields conditionallows checking the value of a field, such asStory Points, to ensure it meets a condition (e.g., is empty).

Exact Extract from Documentation:

Issue fields condition

TheIssue fields conditionchecks the value of an issue field against a specified criterion.

To check if Story Points is empty:

Add anIssue fields condition.

SelectStory Pointsas the field.

Set the condition tois empty.Note: This condition ensures the rule only proceeds if the field has no value.(Source: Atlassian Support Documentation, "Jira automation conditions")

Why This Fits: TheIssue fields condition on whether Story Points isemptyensures the rule only comments on Sub-tasks if the Story is unestimated, satisfying the condition requirement.

Why Other Options Are Incorrect:

Related issues condition on Issues in the sprint (Option C):

ARelated issues conditionchecks if related issues (e.g., Sub-tasks, Epics) meet certain criteria. The requirement does not involve checking the sprint status of issues, only that the Story is unestimated and comments are added to Sub-tasks. This condition is irrelevant to the rule.

Extract from Documentation:

TheRelated issues conditionchecks if related issues meet a condition (e.g., all Sub-tasks are resolved). It is not needed for commenting on Sub-tasks without additional criteria.

(Source: Atlassian Support Documentation, "Jira automation conditions")

Branch rule on Stories (Option D):

ABranch rule on Storieswould target Stories, not Sub-tasks. Since the rule needs to comment on the Sub-tasks of the updated Story, a branch on Sub-tasks (Option A) is required, not Stories.

Extract from Documentation:

ABranch ruletargets specific related issues (e.g., Sub-tasks, Epics). Choose the correct issue type to match the action (e.g., Sub-tasks for commenting on Sub-tasks).

(Source: Atlassian Support Documentation, "Jira automation actions")

Additional Notes:

The complete rule would look like this:

Trigger: Issue Updated (filter to Story issue type).

Condition: Issue fields condition (Story Points is empty).

Action: Branch rule on Sub-tasks.

Action: Comment on issue (add the desired comment).

The rule assumes theStory Pointsfield is available and Sub-tasks exist for the Story.

The rule can be configured inProject settings > Automation(for project-level rules) orSettings > System > Automation rules(for global rules).

When moving issues between two company-managed projects with different field configurations using a bulk operation, certain fields may need to be updated due to differences in workflows, field configurations, or project-specific settings. The field that willdefinitelybe updated isStatus(Option E), as issues must be mapped to a valid status in the target project’s workflow.

Explanation of the Correct Answer (Option E):

Each company-managed project can have its ownworkflow scheme, which assigns workflows to issue types. When moving issues between projects, the source project’s workflow may have different statuses than the target project’s workflow. During a bulk move, you must map the current status of each issue to a valid status in the target project’s workflow, as the source status may not exist in the target workflow. This status mapping is a mandatory step in the bulk move process, ensuring thatStatusis always updated.

Exact Extract from Documentation:

Move issues between projects

When moving issues to a different project in Jira Cloud, you must map the issue’s status to a valid status in the target project’s workflow.

To move issues:

Select issues and chooseBulk change>Move issues.

Choose the target project and issue type.

Map the source status to a target status for each issue type.Note: Status mapping is required because projects may use different workflows with distinct statuses.(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Why This Fits: The bulk move operation always requires mapping theStatusfield to a valid status in the target project’s workflow, makingStatusthe field that will definitely be updated.

Why Other Options Are Incorrect:

Assignee (Option A):

TheAssigneefield is not necessarily updated during a move. If the assignee is a valid user in the target project and has theAssignable Userpermission, the assignee remains unchanged. Only if the assignee is invalid (e.g., lacks permissions) might you need to update it, but this is not guaranteed.

Extract from Documentation:

TheAssigneefield is preserved during a move unless the user is not assignable in the target project, in which case you may be prompted to choose a new assignee.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Custom fields (Option B):

Custom fieldsmay need to be updated if the target project’s field configuration requires values for fields that were not required in the source project. However, this is not guaranteed, as it depends on the specific field configurations. If the custom fields are optional or have compatible values, no update is needed.

Extract from Documentation:

Custom fields may require updates if the target project’s field configuration mandates values not required in the source project. This is not always necessary.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Resolved Date (Option C):

TheResolved Date(orResolution Date) is a read-only system field set automatically when an issue’sResolutionis set (e.g., via a workflow transition). It is not directly updated during a move unless the status mapping triggers a resolution change, which is not guaranteed.

Extract from Documentation:

TheResolution Dateis set by workflow transitions, not directly by moving issues. It remains unchanged unless the move alters the resolution.

(Source: Atlassian Support Documentation, "Configure advanced work item workflows")

Components (Option D):

Componentsare project-specific, and the target project may have different components. During a move, you may need to map or clear components if the source components do not exist in the target project. However, this is not guaranteed, as components may be compatible or optional.

Extract from Documentation:

Components may need to be mapped or cleared if the target project has different components, but this is not always required.

(Source: Atlassian Support Documentation, "Move issues in Jira Cloud")

Additional Notes:

The bulk move operation is performed viaIssues > Search for issues > Bulk change > Move issues, requiring theMove Issuespermission.

The mandatory status mapping ensures compliance with the target project’s workflow, makingStatusthe only field always updated.

Other fields (e.g.,Assignee,Custom fields) may be updated depending on configurations, but onlyStatusis certain.