- Overview
- Legend
- Overall parity at a glance
- Surface points
- Display conditions and visibility rules
- Templating
- Dynamic templates: side-by-side syntax and recipes
- Built-in variables
- Operators
- Recipe 1: Show summary and status
- Recipe 2: Conditional message based on status
- Recipe 3: Combined condition (priority + status)
- Recipe 4: Loop over labels
- Recipe 5: Loop over linked issues with index and “no items” branch
- Recipe 6: JQL-driven table of related issues
- Recipe 7: Format a date
- Recipe 8: Custom field value with a default
- Recipe 9: Check that current user is the assignee
- Recipe 10: Group / role membership check
- Recipe 11: Render a status as a badge
- Recipe 12: Show the assignee
- Recipe 13: Math (working days remaining)
- Recipe 14: Loop with separator (no trailing comma)
- Recipe 15: Filter and sort linked issues in the template
- Velocity-only constructs (no direct Forge equivalent)
- Forge-only constructs (no direct DC equivalent)
- Custom JavaScript per configuration
- Visual presentation
- Field rendering inside messages
- Linked-issues panel
- Configuration scope and admin UI
- Configuration export / import
- Localization
- Permissions and visibility model
- Audit and change history
- APIs and automation
- Rovo AI integration (Forge-only)
- UI Modifications (Forge-only)
- JSM portal support
- Schedulers and background jobs (Forge)
- Unique features per version
- Summary: picking the right version
Overview
Message Field ships in two flavors, built for different Atlassian hosting models:
- Data Center (DC) - the original Java plugin for Jira Data Center and Server. Built around a single
Message fieldcustom field that injects messages into issue, create, edit, transition, and Service Desk screens through Velocity templates and CSS-selector-based DOM injection. Ships with 8 UI languages, ScriptRunner Behaviours integration, custom JavaScript per configuration, and a delegated administration model. - Cloud (Forge) - the Atlassian Forge app for Jira Cloud, the only supported way to run Message Field on Cloud (Message Field has never had a Connect Cloud version). Built on Forge UI Kit modules (
issuePanel,issueActivity,issueContext,issueAction,customFieldType, JSM portal panels). Brings a modern template engine with filters/loops/conditionals, configuration import/export, Rovo AI agents, UI Modifications, JSM customer/unlicensed portal support, and Cloud-native scheduling.
| The tables on this page list features side by side in a fixed **DC | Forge** column order for the DC -> Forge evaluation path. |
The two versions are independent codebases with different architectures (Java + Velocity vs. TypeScript + Forge UI Kit). When you move from Data Center to Cloud with the Jira Cloud Migration Assistant (JCMA), your Message Field configurations move with it: each DC field configuration becomes the configuration of the matching field context of the migrated Message Field custom field (Custom Field module). Configurations that use DC-only features arrive disabled for review. To move only some messages, import a Data Center export file instead. See Migration from Data Center for the requirements, what moves, what does not, and what to check before you enable a migrated configuration.
Legend
| Symbol | Meaning |
|---|---|
| OK | Supported in this version |
| NO | Not supported in this version |
| - | Not applicable to this version |
Read OK as “supported”, NO as “not supported”, and “-“ as “the concept does not apply to this platform”.
Overall parity at a glance
| Area | DC | Forge |
|---|---|---|
| Surface points (where a message appears) | Custom field on every screen, plus DOM-injected blocks via CSS selectors on view / create / edit / transition / Service Desk screens | 12 native module types: 4 Jira issue surfaces (issuePanel, issueActivity, issueContext, issueAction), 1 custom field, 1 dashboard gadget, and 6 JSM portal modules (Panel, Header, Subheader, Footer, plus Footer / Subheader for the create form) |
| Configuration scope | Field-context (per project + issue type), global “all-fields” overlay, project-delegated configs | Global, per project, per issue type, per JSM request type |
| Templating | Velocity templates with full JVM helper objects (Issue, Project, JQL, Links, MathTool, JSON) | Custom template engine (variables, conditionals, loops, filters, functions, operators) |
| Custom JavaScript per message | OK (per-config code field, runs in browser) |
NO (Forge UI Kit forbids arbitrary JS) |
| UI languages (admin + end-user) | 8 (en, de, es, fr, ja, pt, ru, zh) | 2 (en-US, de-DE) |
| Display conditions | Status, group, role, link type, JQL, show-only-on-create, hide-on-status, hide-from-group / role | Project, issue type, JSM request type, JQL, user-field membership, module-level enable/disable, status (via JQL), time window (via template condition) |
| Configuration audit | OK (dedicated Audit Log page, AO-stored history) | NO (no built-in audit log) |
| Configuration export / import | NO | OK (bulk JSON export / import, up to 200 configs per import) |
| Rovo AI agents | NO | OK (Message Panel Agent, 7 actions + Message Panel Admin Agent, 23 actions of which 15 are user-facing) |
| UI Modifications | NO | OK (UIM logger module, GIC field-context sync) |
| JSM portal (customer / unlicensed access) | OK (Service Desk via selectorViewSD / selectorCreateSD CSS injection) |
OK (6 native portal modules with unlicensedAccess: customer, unlicensed) |
| Background jobs | NO (rendering is on demand; the plugin manifest declares no background tasks) | OK (3 schedulers: personal data report, UIM sync, custom field cleanup) |
| ScriptRunner Behaviours integration | OK (documented integration patterns) | NO (out of scope on Forge) |
| Insight / Assets (CMDB) helpers in templates | NO (not available - the Velocity helper is not exposed) | NO |
| REST API for configuration | OK (/rest/message-field, /rest/message-field-admin, v1.0) |
OK (Forge resolver + Rovo actions, no public REST) |
The rest of the page breaks these areas down feature by feature.
Surface points
Where the configured message can appear on an issue.
| Surface | DC | Forge | Notes |
|---|---|---|---|
| Issue view (custom field renderer) | OK (Velocity view.vm) |
OK (customFieldType.view, experiences issue-view, portal-view) |
DC always renders inside the custom field row; Forge renders inside the Forge custom field surface |
| Issue create dialog | OK (Velocity edit.vm, plus DOM injection via selectorCreate) |
OK (customFieldType.edit, experience issue-create) |
|
| Issue edit dialog | OK (Velocity edit.vm, plus selectorEdit) |
OK (customFieldType.edit, experience issue-view) |
|
| Workflow transition screen | OK (selectorTransition CSS injection) |
OK (customFieldType.edit, experience issue-transition) |
DC injects via the transition selector; Forge uses the transition experience flag |
| Issue navigator column | OK (Velocity column-view.vm) |
NO | DC ships a dedicated column-view template |
| XML / REST export of issue value | OK (Velocity viewAsXml.vm) |
NO | DC includes the rendered value in classic XML export |
| Issue panel (main column, below the description) | NO (no dedicated panel module) | OK (jira:issuePanel) |
Forge-native panel that does not require a custom field on screens |
| Activity tab | NO | OK (jira:issueActivity) |
|
| Issue context panel | NO | OK (jira:issueContext) |
|
| Issue action menu | NO | OK (jira:issueAction) |
|
| JSM portal request detail | OK (selectorViewSD CSS injection) |
OK (jiraServiceManagement:portalRequestDetailPanel) |
Both render to the customer view |
| JSM portal create request | OK (selectorCreateSD CSS injection) |
OK (jiraServiceManagement:portalSubheader and portalFooter, both registered on pages view_request + create_request) |
|
| JSM portal subheader (above request content) | NO | OK (jiraServiceManagement:portalSubheader, pages view_request + create_request) |
Forge-only surface |
| JSM portal footer (below request content) | NO | OK (jiraServiceManagement:portalFooter, pages view_request + create_request) |
Forge-only surface |
| JSM unlicensed / portal-only customer access | OK (server-rendered, follows Service Desk customer model) | OK (unlicensedAccess: customer, unlicensed declared on all 3 portal modules) |
|
| Refined for Jira customer portal | OK (web-resource contexts customerportal, refinedcustomerportal, customer-view-resources-context) |
NO | DC has explicit Refined integration |
The two versions split surface points along their platform constraints. DC uses CSS-selector DOM injection to land on any screen that renders matching markup; Forge uses typed Forge modules that opt in to specific issue and portal areas. DC therefore covers screens (column view, XML, transition) that Forge does not, while Forge covers panels (issuePanel, issueActivity, issueContext, issueAction, three JSM portal slots) that DC does not.
Display conditions and visibility rules
Conditions that decide whether a configured message is shown to a given user on a given issue.
| Condition | DC | Forge | Notes |
|---|---|---|---|
| Project (allow-list) | OK (via field-context bindings) | OK (filterSettings.projects) |
|
| Issue type (allow-list) | OK (via field-context bindings) | OK (filterSettings.issueTypes) |
|
| Status (show only when in…) | OK (statuses) |
OK (Display JQL status in (...) or Display condition on fields.status) |
DC stores statuses by id; in JQL you can use the status name or id |
| Status (hide when in…) | OK (dontShowStatuses) |
OK (Display JQL status not in (...)) |
Forge expresses it as a negated JQL |
| Group membership (show to…) | OK (groups) |
NO (use JQL or user-field instead) | |
| Group membership (hide from…) | OK (dontShowGroups) |
NO | |
| Project role (show to…) | OK (roles) |
NO (use JQL instead) | |
| Project role (hide from…) | OK (dontShowRoles) |
NO | |
| User-field membership (e.g. assignee, reporter, custom user picker) | OK (via Velocity expressions) | OK (filterSettings.userFieldIds) |
Forge has a first-class user-field filter |
| JQL condition | OK (jqlCondition) |
OK (filterSettings.displayJql) |
Both let you gate visibility by an arbitrary JQL expression |
| JSM request type | NO (hidden behind selectorViewSD / selectorCreateSD CSS injection) |
OK (filterSettings.requestTypes) |
Forge filters portal modules by request type natively |
| Show only on create | OK (showOnlyCreate) |
NO | DC has a dedicated “create only” flag |
| Linked-issue presence (show only if links exist / have status…) | OK (linkTypes, link, linkedStatuses, isShowIsHasLinks) |
OK (linkTypeSettings.linkType: EMPTY / JQL / LINKED_ISSUES) |
DC ties visibility to a specific linked-status set; Forge ties content to a JQL or link-type set and shows a dynamic table |
| Module-level enable / disable toggle | OK (per configuration) | OK (isEnabled per configuration) |
|
| Permission-based render (hide value if user cannot view issue) | OK ($permissionHelper and the permission-checked helper variants exposed to Velocity) |
OK (Forge resolver enforces req.context.accountId against issue permissions) |
|
| Per-user-locale rendering | OK (Velocity renders in the viewing user’s Jira locale, 8 languages) | OK (resolver reads read:user-configuration:jira for locale, 2 languages) |
|
| Time-window visibility (start / stop dates) | OK (start and stop fields on the configuration) |
OK (Display condition, e.g. {{ isPast('2026-11-01T00:00:00Z') and isFuture('2026-11-30T23:59:59Z') }}) |
DC stores start / stop in the server time zone; in Forge you write the dates with an explicit time zone |
Templating
How the message body is composed.
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Templating language | Velocity (Apache Velocity, Atlassian sandbox) | Custom template engine (in-house, Forge-safe) | Different paradigms |
| Variable syntax | $variable / ${variable} (Velocity references) |
{{ issue.key }} (HTML-escaped), {{{ raw }}} (raw HTML), short forms {{ key }} / {{ id }} |
|
| Variables (issue fields, project, user) | OK ($issue, $form, $user, plus $formIssue getters during create / edit) |
OK ({{ issue.* }}, {{ fields.* }}, {{ key }}, {{ id }}) |
Both expose issue, project, and current user |
| Conditionals | OK (#if / #elseif / #else / #end) |
OK ({% if %} / {% elif %} / {% else %} / {% endif %}) |
|
| Loops | OK (#foreach($x in $list)) |
OK ({% for x in list %}) |
|
| Logical operators | OK (&&, ||, !, ==, !=, <, >, etc.) |
OK (and, or, not, in, ==, !=, <, >, ternary condition ? a : b) |
|
| Filters / formatters | OK (Velocity formatters: dates, numbers, strings) | OK (pipe filters: | len, plus date / number / string filters; see Template filters) |
|
| Variable assignment inside template | OK (#set($x = ...)) |
OK ({% set x = ... %}) |
|
| Math operations | OK (Velocity MathTool: add, sub, mul, div, mod, ceil, floor, round, abs, min, max, average) |
OK (functions inside template engine) | |
| JSON parsing in templates | OK (JSON.parse, JSONObject exposed) |
OK (template engine handles JSON-shaped variables) | |
| JQL queries inside templates | OK ($jqlService, $jqlServiceWithCheckPermissions: getIssuesByJQL, getIssueCountByJQL, validateJql) |
OK (configuration-level jql for linked-issue table; template variables for matched issues) |
DC lets templates run arbitrary JQL inline; Forge runs JQL once per panel and exposes the result set to the template |
| Issue-link traversal in templates | OK ($links, $linksWithCheckPermissions: getOutwardIssues, getOutwardLinks, getInwardIssues, getInwardLinks, including form-mode variants) |
OK (configuration-level link types build the displayed set) | |
| Insight / Assets (CMDB) queries in templates | NO (not available on either side) | NO | The Velocity helper is not exposed to templates on DC |
| Render an existing custom field’s value as HTML | OK ($issueFieldRender.getFieldValueHtml(issue, fieldId), $issueFieldRenderWithCheckPermissions) |
OK (40+ field-type renderers, see field rendering) | |
| Render JQL result as a table | OK ($issueFieldRender.getJQLAsTableHtml(jql, max, fields...)) |
OK (configuration-driven linkedIssuesFieldId columns, rowsPerPage 1-100) |
|
| Render IQL (Insight) result as a table | NO (not available on either side) | NO | |
| Read a custom field value with a default fallback | OK ($cfValues.getOrDefault, $cfValues.getFromForm) |
OK (template engine helpers) | |
Cast helpers (toInteger, toLong, toString) |
OK ($cast) |
OK (template engine helpers) | |
| Status / status-list parsing helpers | OK (helpers that parse a status list from a string or from status IDs) | OK (status objects exposed as variables) | |
| Form-time data (during create / edit, before save) | OK ($formIssue with all standard issue getters incl. getAssigneeUser, getReporterUser, getDueDate, getSecurityLevelId, getEnvironment, getAffectedVersions, getFixVersions, getLabels, getResolution, getCreator, isSubTask, getParentObject) |
OK (customFieldType.edit resolver receives the in-progress field set) |
|
| Direct access to JVM managers (ProjectManager, UserManager, IssueLinkManager, GroupManager, EventTypeManager, WorkflowManager, FieldConfigSchemeManager, AvatarService, etc.) | OK ($ComponentAccessor exposes an allowlist of 70+ Jira manager getters) |
NO (Forge UI Kit forbids JVM access) | DC templates can call into almost any Jira component |
Capability tradeoff. DC’s Velocity templating is effectively a sandboxed scripting environment over the Jira JVM, so a template can do almost anything a Java component can. Forge’s template engine is intentionally narrower: it gives you variables, control flow, and filters but no arbitrary code execution. The Forge engine compensates by moving the heavy logic (JQL fetch, field rendering, link traversal) into the configuration itself, so the template stays readable.
Dynamic templates: side-by-side syntax and recipes
The previous section is a feature checklist. This section is a migration aid: side-by-side templates so a DC author can map a working Velocity snippet to a working Forge template.
See also: DC docs Dynamic Templates and Examples; Forge docs Templates, Filters, Advanced.
Built-in variables
| Purpose | DC (Velocity) | Forge (template engine) |
|---|---|---|
| The current issue (saved data) | $issue (Jira Issue object; not defined when $context == "CREATE") |
{{ issue }} (Jira issue REST shape; always defined) |
| Form data (during create / edit, before save) | $form (raw JSON of the form) |
Forge resolver receives in-progress field set; exposed under {{ fields }} shortcuts in the same way as saved data |
| Combined issue + form (recommended) | $formIssue (validated, real-time) |
Built into {{ issue.* }} for Forge - the resolver merges form-time and saved values |
| Issue key / id shortcuts | $issue.key, $issue.id |
{{ key }} / {{ id }} (short forms), or {{ issue.key }} / {{ issue.id }} |
| Standard fields | $issue.summary, $issue.status.name, $issue.priority.name, $issue.assignee.displayName, $issue.reporter.displayName, $issue.dueDate, $issue.created, $issue.updated, $issue.labels |
{{ fields.summary }}, {{ fields.status.name }}, {{ fields.priority.name }}, {{ fields.assignee.displayName }}, {{ fields.reporter.displayName }}, {{ fields.duedate }}, {{ fields.created }}, {{ fields.updated }}, {{ fields.labels }} |
| Project | $issue.projectObject.key |
{{ fields.project.key }}, shortcut {{ project.key }} |
| Custom field value | $cfValues.get($issue, "customfield_10200"), $cfValues.getFromForm("customfield_10200"), $cfValues.getOrDefault(..., default) |
{{ issue.fields.customfield_10001 }} (by field id only - there is no access by field name) |
| Current viewer | $currentUser, $locale, $language, $country, $timeZone |
{{ currentUser.accountId }}, {{ currentUser.displayName }}, {{ currentUser.locale }}, alias {{ user }}. No email (emailAddress never resolves); timeZone is always UTC |
| Server / now timestamps | $currentDateTime, $nowInUserTimeZone |
Use {{ "now" | date(...) }} / per-field date filters |
| Transition context | $context == "TRANSITION", $transitionId, $transitionName, $previousStatusId, $previousStatusName, $dateOfLastTransition, $secAfterLastTransition |
Custom field edit resolver receives the transition context via Forge req.context.extension; surfaced as variables in the template |
| Surface context | $context (CREATE / EDIT / TRANSITION / VIEW_ISSUE / CREATE_SD / VIEW_SD) |
Implicit in the chosen module (jira:issuePanel, customFieldType.edit, JSM portal modules); no single context variable - each module is a separate registration |
| Display config | $fieldDisplayConfig (message type, location, etc.) |
Configured per-config in admin UI; not surfaced as a template variable |
| Linked issues collection | $links.getOutwardIssues("blocks"), $links.getInwardIssues(...), plus $linksWithCheckPermissions.* |
{{ linkedIssues }} array (built by configuration’s linkTypeSettings), plus {{ linkedIssues.length }} |
| Run a JQL search inside a template | $jqlService.getIssuesByJQL("project = X", 50), $jqlService.getIssueCountByJQL(...), plus $jqlServiceWithCheckPermissions.* |
NO inline JQL execution. Use the configuration’s linkTypeSettings.linkType: JQL + jql field. Result lands in {{ linkedIssues }} |
| Render an existing field as HTML | $issueFieldRender.getFieldValueHtml($issue, "customfield_10001") (plus WithCheckPermissions variant) |
No equivalent renderer. Read the value and build the markup in the template: {{ issue.fields.status.name }}, {{ issue.fields.assignee.displayName }} |
| Parse JSON | $JSON.parse(stringValue) |
Variables are already JSON-typed; no parse step needed. Reverse direction: {{ data | json(2) }} |
| Direct JVM access | $ComponentAccessor.projectManager.getProjectByKey("X"), plus 70+ other manager getters |
NO. Forge UI Kit forbids JVM access; equivalent data must come from Jira REST through the resolver |
| Math | $mathTool.add($a, $b), sub, mul, div, mod, ceil, floor, round, min, max, average |
Number filters: {{ value | round }}, {{ value | ceil }}, {{ value | floor }}, {{ value | percent(2) }}, plus operators + - * / % |
| Permission check | $permissionHelper.hasPermission("BROWSE_PROJECTS", $issue.reporter) (40+ permission keys: ADD_COMMENTS, ADMINISTER_PROJECTS, ASSIGN_ISSUES, EDIT_ISSUES, etc.) |
Resolver enforces read:jira-work and field-level permissions before the template runs; no in-template permission helper |
| Type cast | $cast.toLong("1"), $cast.toInteger(...), $cast.toString(1) |
Implicit; values are typed at the source |
| Group membership | $userGroupService.isUserInGroup("john.doe", "jira-administrators"), $userGroupService.isUserInGroup($currentUser, "developers") |
NO direct group-check helper. Use the configuration’s filterSettings.userFieldIds to filter visibility, or filter at the JQL source |
| Base URL | $baseUrl |
Available via Forge bridge.getContext() server-side; not exposed as a template variable |
Delegated-config restriction (DC). Several DC variables -
$links,$jqlService,$issueFieldRender,$ComponentAccessor,$permissionHelper,$cast,$userGroupService- are unavailable when the configuration was created through the project-delegated UI (only*WithCheckPermissionsversions stay). Forge does not have this distinction.
Operators
| Operator | DC (Velocity) | Forge |
|---|---|---|
| Equality | ==, != |
==, != |
| Comparison | <, <=, >, >= |
<, <=, >, >= |
| Logical | &&, ||, ! |
and, or, not |
| Membership in array | $array.contains($x) (Java method call) |
{% if x in array %} |
| Ternary | #if(...) yes #else no #end |
{{ condition ? "yes" : "no" }} |
| Variable assignment | #set($x = ...) |
{% set x = ... %} |
| Loop variables | $velocityCount (1-based), $foreach.index, $foreach.first, $foreach.last |
loop.index (0-based), loop.index1 (1-based), loop.first, loop.last, loop.even, loop.odd, loop.length |
| Loop control | #break (Velocity 2.x), #continue |
{% break %}, {% continue %} |
| Loop “empty” branch | Manual: #if($list.size() == 0) ... #end |
Built-in: {% for x in arr %} ... {% empty %} ... {% endfor %} |
Recipe 1: Show summary and status
DC (Velocity):
<b>$formIssue.key</b> - $formIssue.summary
Status: $formIssue.status.name
Forge:
<b>{{ key }}</b> - {{ fields.summary }}
Status: {{ fields.status.name }}
Recipe 2: Conditional message based on status
DC:
#if($formIssue.status.name == "In Progress")
Work in progress, please don't reassign.
#elseif($formIssue.status.name == "Done")
Already completed - no further changes needed.
#else
Please pick this up.
#end
Forge:
{% if fields.status.name == "In Progress" %}
Work in progress, please don't reassign.
{% elif fields.status.name == "Done" %}
Already completed - no further changes needed.
{% else %}
Please pick this up.
{% endif %}
Recipe 3: Combined condition (priority + status)
DC:
#if($formIssue.priority.name == "High" && $formIssue.status.name != "Done")
<b>High-priority issue needs attention</b>
#end
Forge:
{% if fields.priority.name == "High" and fields.status.name != "Done" %}
<b>High-priority issue needs attention</b>
{% endif %}
Recipe 4: Loop over labels
DC:
#foreach($label in $formIssue.labels)
- $label
#end
Forge:
{% for label in fields.labels %}
- {{ label }}
{% endfor %}
Recipe 5: Loop over linked issues with index and “no items” branch
DC:
#set($blockers = $linksWithCheckPermissions.getOutwardIssues("blocks"))
#if($blockers.size() == 0)
No blockers
#else
#foreach($b in $blockers)
$velocityCount. $b.key - $b.summary
#end
#end
Forge:
{% for b in linkedIssues %}
{{ loop.index1 }}. {{ b.key }} - {{ b.fields.summary }}
{% empty %}
No blockers
{% endfor %}
(In Forge the linked-issue set is built by linkTypeSettings.linkType: LINKED_ISSUES with linkTypes: [{ name: "blocks", direction: "outward" }] in the configuration, not in the template.)
Recipe 6: JQL-driven table of related issues
DC:
#set($jql = "project = $formIssue.projectObject.key AND status = Open")
$issueFieldRenderWithCheckPermissions.getJQLAsTableHtml($jql, 10, "key", "summary", "assignee", "duedate")
Forge: the JQL and column list move into the configuration, not the template:
linkTypeSettings:
linkType: JQL
jql: 'project = "{{ project.key }}" AND status = Open'
maxIssues: 10
displaySettings:
linkedIssuesFieldId: ["key", "summary", "assignee", "duedate"]
rowsPerPage: 10
The template then iterates if needed:
{% for r in linkedIssues %}
- {{ r.key }} {{ r.fields.summary }} ({{ r.fields.assignee.displayName | default("unassigned") }})
{% endfor %}
Recipe 7: Format a date
DC:
#set($sdf = $ComponentAccessor.getComponent("com.atlassian.jira.datetime.DateTimeFormatterFactory"))
Due: $formIssue.dueDate
(Most teams just print $formIssue.dueDate and rely on Jira’s default formatting; the JVM-level formatter is available but rarely worth the friction.)
Forge:
Due: {{ fields.duedate | date("yyyy-MM-dd") }}
Updated: {{ fields.updated | fromNow }}
(Date filters: date(format, timezone), fromNow, addDays(n), addHours(n). Format tokens: yyyy MM dd HH mm ss.)
Recipe 8: Custom field value with a default
DC:
#set($team = $cfValues.getOrDefault($issue, "customfield_10200", "Unassigned"))
Team: $team
Forge:
Team: {{ issue.fields.customfield_10200 | default("Unassigned") }}
Recipe 9: Check that current user is the assignee
DC:
#if($formIssue.assignee == $currentUser.username)
This issue is assigned to <b>you</b>.
#end
Forge:
{% if fields.assignee.accountId == currentUser.accountId %}
This issue is assigned to <b>you</b>.
{% endif %}
(Note the identifier shift: DC compares usernames, Forge compares accountId.)
Recipe 10: Group / role membership check
DC:
#if($userGroupService.isUserInGroup($currentUser, "jira-administrators"))
Showing admin-only details: ...
#end
Forge: group / role checks belong on the configuration, not the template. Add the user-field or JQL condition that excludes other users:
filterSettings:
displayJql: 'reporter in membersOf("jira-administrators")'
Or, when the comparison is to a user-picker custom field on the issue, use:
filterSettings:
userFieldIds: ["customfield_12345"]
The configuration is then only resolved for users who match - the template does not need an in-line group check.
Recipe 11: Render a status as a badge
DC:
$issueFieldRenderWithCheckPermissions.getFieldValueHtml($issue, "status")
Forge: there is no field renderer - build the markup from the value:
<span style="padding: 2px 6px; border-radius: 3px; background: #DFE1E6;">{{ issue.fields.status.name }}</span>
Recipe 12: Show the assignee
DC:
$issueFieldRenderWithCheckPermissions.getFieldValueHtml($issue, "assignee")
Forge:
{{ issue.fields.assignee.displayName | default("Unassigned") }}
Recipe 13: Math (working days remaining)
DC:
#set($daysLeft = $mathTool.div($secAfterLastTransition, 86400))
$mathTool.round($daysLeft) days since last transition
Forge:
{{ ((now - fields.updated) / 86400) | round }} days since last update
(or move the calculation into a configuration field if the math is reused.)
Recipe 14: Loop with separator (no trailing comma)
DC:
#foreach($l in $formIssue.labels)
$l#if($foreach.hasNext), #end
#end
Forge: two equivalent forms:
{% for l in fields.labels %}{{ l }}{% if not loop.last %}, {% endif %}{% endfor %}
or simpler with the join filter:
{{ fields.labels | join(", ") }}
Recipe 15: Filter and sort linked issues in the template
DC handles this with custom Velocity loops. Forge has chainable filters:
Forge:
{{ linkedIssues
| filter("fields.status.name", "!=", "Done")
| sortBy("fields.priority.id")
| take(5) }}
Velocity-only constructs (no direct Forge equivalent)
Things you cannot port one-to-one and need to redesign on the configuration level instead of the template level.
| Velocity construct | Why no Forge equivalent | Where to redesign |
|---|---|---|
$jqlService.getIssuesByJQL(...) (inline JQL execution) |
Forge resolves JQL once, server-side, before the template runs | Move JQL into linkTypeSettings.jql; template iterates {{ linkedIssues }} |
$ComponentAccessor.* (any of 70+ Jira managers) |
Forge UI Kit forbids JVM access | Pull the equivalent data through Jira REST in the resolver, expose as a variable |
$permissionHelper.hasPermission(...) |
Forge enforces permissions before render | Configure displayJql / userFieldIds / module conditions |
$userGroupService.isUserInGroup(...) |
No in-template group-check helper | Use displayJql with membersOf("group") or userFieldIds |
Custom JavaScript in the message body (code field on the configuration) |
Forge UI Kit forbids arbitrary client JS | No equivalent. Re-express the logic as filters / conditionals, or delegate to a Rovo agent |
$context == "TRANSITION" (single variable that switches behavior across surfaces) |
Each Forge surface is its own module | Create a separate configuration per module if behavior must differ |
Forge-only constructs (no direct DC equivalent)
| Forge construct | Why DC has no equivalent | Notes |
|---|---|---|
Pipe filters (| upper, | truncate, | date(...), | sortBy(...), | filter(...), | take(n), | join(...), | default(...), | coalesce(...), | match(regex), etc.) |
Velocity has no pipe operator; same operations require explicit Java method calls and helper objects | 45+ filters available; chainable |
issueLink filter (issue key → key as text) |
Velocity has no pipe filters at all | Not a URL builder: it returns the key unchanged. Build the link yourself with a plain anchor on /browse/, just as DC does from $issue and the base URL |
loop.even / loop.odd / loop.length |
Velocity exposes only $foreach.index, $foreach.first, $foreach.last, $velocityCount |
Useful for zebra-stripe styling |
{% empty %} branch on for |
Velocity requires a separate #if($list.size() == 0) |
|
| Markdown / ADF render type | DC renders raw Velocity output as HTML | |
Modal-mode templates (with modalShowOncePerIssue, modalSize, modalAppearance) |
DC has no modal mode |
Custom JavaScript per configuration
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Per-configuration custom JS that runs in the user’s browser | OK (code field on the configuration, executed alongside the rendered message) |
NO | Forge UI Kit forbids arbitrary client JS |
| Global “when to run JS” toggle | OK (whenRunJavaScript on global config) |
NO | |
| Show-default-message toggle (control fallback while async config loads) | OK (isShowDefaultMessage) |
OK (Forge resolves config server-side, no fallback flicker) | |
| Cache busting / “wait” hint for clients | OK (wait flag and timeout returned with the configuration payload) | OK (a data-version stamp on the cached configuration payload invalidates the browser cache) | |
| ScriptRunner Behaviours integration | OK (documented patterns in DC docs script-runner-behaviours, script-runner-examples) |
NO | |
| HTML / JS examples library | OK (DC docs html-examples, java-script-examples) |
OK (Rovo Admin Agent ships ready-to-use JSON patterns: subtasks, blockers, epic, modal-warning, workload, release, security, jsm-portal-status, message-progress-bar, etc.) |
Visual presentation
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Plain text message | OK | OK (messageRenderType: plain_text) |
|
| HTML message | OK (raw Velocity / HTML) | OK (messageRenderType: html, converted to Forge UI Kit components before rendering) |
|
| Markdown message | NO | OK (messageRenderType: md) |
|
| ADF (Atlassian Document Format) message | NO | OK (messageRenderType: adf) |
|
| Display as flag (toast-style) | OK (asFlag) |
OK (modalFlagOnOpen: a Jira flag with the title and the message as plain text when the issue is opened, Issue Panel / Issue Activity / Issue Context; modalFlagOpensModal adds an Open button that opens the modal) |
DC shows the message itself as a flag; Forge shows a flag on issue open, with or without a modal |
| Per-config background color | OK (backgroundColor, custom hex) |
NO (use wrapper presets) | |
| Per-config text color | OK (textColor, custom hex) |
NO | |
| Per-config icon | OK (icon, iconColor, custom hex) |
NO (use wrapper presets) | |
| Severity wrapper (info / warning / error / success / change / custom) | NO (color-driven) | OK (messageWrapperType: custom | info | warning | error | success | change, plus messageWrapperTitle) |
Forge uses a fixed semantic palette; DC uses arbitrary colors |
| Modal / dialog presentation | NO | OK (modalSettings: showInModal, modalSize (small / medium / large / x-large), modalAppearance (warning / danger), modalAutoOpen, modalFlagOnOpen, modalFlagOpensModal, modalShowOncePerIssue, modalButtonText, modalButtonAppearance, modalCloseButtonText) |
Forge-only modal mode |
| Show-once-per-issue tracking | NO | OK (modalShowOncePerIssue: an auto-open modal or a flag does not show again for the issue and configuration for 7 days, remembered in the viewer’s browser) |
Field rendering inside messages
When the message body needs to embed values from other Jira fields.
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Embed a single field’s value | OK ($issueFieldRender.getFieldValueHtml(issue, fieldId)) |
OK (template variable) | |
| Embed a permission-checked field value (hide if user cannot read) | OK ($issueFieldRenderWithCheckPermissions) |
OK (Forge resolver enforces field-read permissions) | |
| Render a field as an HTML table | OK (getAsTableHtml) |
OK (configuration-driven table; see linked-issues table below) | |
| Render multiple fields side by side in a configurable table | OK (getAsTableHtml(issue, fieldIds...)) |
OK (displaySettings.linkedIssuesFieldId array) |
|
| Render JQL result as a table | OK (getJQLAsTableHtml(jql, max, fieldIds...)) |
OK (panel-level JQL + columns + rowsPerPage) |
|
| Format dates | OK (dateFormat(date, pattern)) |
OK (template engine date filter) | |
Replace newlines with <br/> for HTML |
OK (replaceNewlineCharactersForHtml) |
OK (HTML render type handles this) | |
| Render arbitrary number of standard + custom field types | OK (whatever Jira’s own renderer supports) | OK (40 dedicated renderers, one per supported field type) |
Linked-issues panel
A common use-case: “show issues linked to this one in a configurable table.” DC builds this through Velocity helpers; Forge has a dedicated configuration block.
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Source: explicit issue link types (e.g. blocks, is-blocked-by) | OK (getOutwardIssues(linkType), getInwardIssues(linkType)) |
OK (linkTypeSettings.linkType: LINKED_ISSUES, linkTypeSettings.linkTypes: [{id, name, direction, directionName}]) |
|
| Source: arbitrary JQL | OK ($jqlService.getIssuesByJQL(jql, max)) |
OK (linkTypeSettings.linkType: JQL, linkTypeSettings.jql) |
|
| Filter linked issues by status | OK (linkedStatuses) |
OK (via JQL or rendered-table sorting) | |
| Cap maximum issues returned | OK (max parameter on JQL helpers) |
OK (linkTypeSettings.maxIssues, 1-1000) |
|
| Configurable columns to display | OK (getJQLAsTableHtml(jql, max, fields...)) |
OK (displaySettings.linkedIssuesFieldId) |
|
| Pagination | NO | OK (displaySettings.rowsPerPage, 1-100) |
|
| Show / hide name, description, count, JQL link | OK (isShowIsHasLinks, layout fixed in templates) |
OK (isShowName, isShowDescription, isShowCount, isShowJqlLink) |
|
| Permission-aware filtering of linked issues | OK ($linksWithCheckPermissions, $jqlServiceWithCheckPermissions) |
OK (Forge resolver runs JQL as the current user) | |
| Cycle detection in link graphs | NO | OK (Rovo detectCycles action; cycle-safe traversal in buildRelationshipTree) |
|
| Multi-level relationship tree (1-5 levels) | NO | OK (Rovo buildRelationshipTree, analyzeImpact with maxDepth 1-5 for impact, 1-10 for cycles) |
Configuration scope and admin UI
How and where administrators create and manage configurations.
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Per-field-context configuration (project + issue type via Jira’s field configuration scheme) | OK (custom field, contexts) | OK (per-config filterSettings.projects + filterSettings.issueTypes) |
DC follows Jira’s native field-context model; Forge uses configuration-internal filters |
| Global admin page | OK (settings for all fields, /secure/jibrokMessageFieldSettingsForAllFields) |
OK (jira:adminPage, condition user_is_admin) |
|
| Project-level admin page | OK (/secure/jibrokMessageFieldDelegated.jspa) |
OK (jira:projectSettingsPage, condition user_is_admin OR user_is_project_admin) |
|
| Stats / overview page | OK (/secure/jibrokMessageFieldStats: total fields, project coverage, screen usage by Create / View / Edit, message type distribution, fields not on any screens warning) |
OK (Rovo healthCheck, findBrokenConfigs actions; Bulk Operations page) |
|
| JQL performance monitoring | OK (Statistics page analyzes every JQL condition: validation, execution time with 250 ms / 5 s thresholds, issue count flagging at >10 000, error and timeout indicators) | OK (Rovo validateExistingConfig and healthCheck actions catch broken JQL per config) |
DC has a dedicated dashboard; Forge surfaces this through Rovo |
| Audit log page | OK (/secure/jibrokMessageFieldAuditLog, backed by a stored change history) |
NO | DC-only |
| ScriptRunner Behaviours settings admin page | OK (separate admin page with Timeout (ms), Show default message? (Yes/No), When the JavaScript should run? (after default message / after behaviour or timeout)) |
NO | DC-only |
| Post-install / post-update onboarding pages | OK (jibrokMessageFieldPostInstall, jibrokMessageFieldPostUpdate) |
NO | DC-only |
| Project admin can create configurations (delegation) | OK (a per-configuration delegation flag plus explicit role, group and user lists) | OK (project admins can create / edit configs scoped to their projects when admin condition user_is_project_admin is met) |
DC has explicit per-config delegation lists; Forge uses Jira’s native admin condition |
| Wizard / step-by-step config creation | NO (single form per config) | OK (Rovo Admin Agent: 6-step wizard, getWizardStep) |
|
| Config validation before save | OK (server-side action validation) | OK (validateConfiguration Rovo action; client-side validation in admin UI) |
|
| Config diagnostics (“find broken configs after migration”) | NO | OK (validateExistingConfig, healthCheck, findBrokenConfigs Rovo actions) |
|
| Clone existing configuration | NO (manual copy) | OK (cloneConfiguration Rovo action; UI clone button) |
|
| Toggle configuration enabled / disabled | OK | OK (toggleConfiguration Rovo action) |
Configuration export / import
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Export single configuration | NO | OK (per-config and per-project export) | |
| Bulk export (whole site) | NO | OK (bulkExportConfigurations, with export metadata in the bundle) |
|
| Bulk import | NO | OK (bulkImportConfigurations, max 200 configs per call) |
|
| Skip duplicates on import | NO | OK (skipDuplicateNames flag) |
|
| Site-to-site move | NO (manual recreate) | OK (export + import) | |
| Configuration backup | NO | OK (export to JSON) |
Forge-only feature. Use it for site-to-site moves and configuration backups. DC users currently have no parallel feature.
Localization
UI languages shipped with the app. Per-issue rendering in the user’s locale is supported by both versions.
| Language | DC | Forge |
|---|---|---|
| English (en-US) | OK (messagefield.properties, default) |
OK (locales/en-US.json, default + fallback) |
| German (de-DE) | OK (messagefield_de.properties) |
OK (locales/de-DE.json) |
| Spanish (es) | OK (messagefield_es.properties) |
NO |
| French (fr) | OK (messagefield_fr.properties) |
NO |
| Japanese (ja) | OK (messagefield_ja.properties) |
NO |
| Portuguese (pt) | OK (messagefield_pt.properties) |
NO |
| Russian (ru) | OK (messagefield_ru.properties) |
NO |
| Chinese (zh) | OK (messagefield_zh.properties) |
NO |
| Total bundled UI languages | 8 | 2 |
DC carries a richer translation set inherited from years of localization work. The Forge build is currently English + German with English fallback, and adds new locales on demand.
Permissions and visibility model
Who can administer configurations and what hides a message at render time.
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Jira global admin can manage all configurations | OK (a Jira global-permission condition on the admin web sections) | OK (user_is_admin condition on jira:adminPage) |
|
| Project admin can manage project configurations | OK (a delegation web condition, plus the per-configuration role / group / user lists) | OK (user_is_project_admin condition on jira:projectSettingsPage) |
|
| Specific roles / groups / users can be delegated admin rights | OK (isDelegated, delegatedRoles, delegatedGroups, delegatedUsers) |
NO (binary admin / project-admin) | DC has finer-grained delegation |
| Hide message from a specific group | OK (dontShowGroups) |
NO (use JQL or user-field filter) | |
| Hide message from a specific role | OK (dontShowRoles) |
NO (use JQL or user-field filter) | |
| Show message only to a specific group | OK (groups) |
NO (use JQL or user-field filter) | |
| Show message only to a specific role | OK (roles) |
NO (use JQL or user-field filter) | |
| JQL-based visibility filter | OK (jqlCondition) |
OK (displayJql) |
|
| User-field-based visibility filter (e.g. only show to users in a specific user-picker custom field) | OK (Velocity expressions) | OK (userFieldIds) |
|
| Issue-view permission check on render | OK (the plugin checks the viewing user’s issue-browse permission before rendering; $permissionHelper.hasPermission is available in templates) |
OK (Forge resolver enforces accountId permissions) |
|
| Issue-edit permission check on render | OK (the plugin checks the user’s issue-edit permission before rendering) | OK | |
| Permission-aware linked-issue queries | OK ($linksWithCheckPermissions, $jqlServiceWithCheckPermissions) |
OK (resolver runs JQL as current user) | |
| IDOR protection on configuration access | N/A (server-side, identity from session) | OK (resolver prefers req.context over req.payload, validates user access to configs from payload) |
Different threat models; see the Security Reference for Auditors |
Audit and change history
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Audit log of configuration changes (who / when / what) | OK (stored change history, with its own REST endpoints and a dedicated admin page) | NO | |
| GDPR personal data report | NO | OK (personal-data-report weekly scheduler, scope report:personal-data) |
|
| Cache versioning for safe rollouts | OK (cache flag and timeout returned by the configuration REST API) | OK (data-version stamps on the global and per-project configuration caches) |
APIs and automation
| Capability | DC | Forge | Notes |
|---|---|---|---|
| REST API for configuration CRUD | OK (/rest/message-field v1.0, /rest/message-field-admin v1.0) |
NO public REST | |
| In-app resolver / RPC | N/A | OK (a single Forge resolver that serves the app’s own UI; not callable from outside the app) | |
| Programmatic configuration via Rovo actions | NO | OK (15 user-facing Rovo actions: getConfigSchema, listConfigurations, getConfiguration, createConfiguration, updateConfiguration, cloneConfiguration, toggleConfiguration, bulkImportConfigurations, bulkExportConfigurations, validateConfiguration, getWizardStep, getConfigExamples, getTemplateHelp, getTroubleshootingHelp, getFieldReference; plus internal lookups and diagnostics: validateExistingConfig, healthCheck, findBrokenConfigs, listProjects, listIssueTypes, listFields, listLinkTypes, listRequestTypes) |
|
| Atlassian webhooks / triggers | NO (no plugin-published triggers) | NO (the only background work is the three schedulers below) | |
| Background scheduled jobs | NO | OK (3 schedulers, see next section) |
Rovo AI integration (Forge-only)
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Conversational agent for end-users to analyze data behind a panel | NO | OK (Message Panel Agent, 7 actions: getMessagePanel, getStatusSummary, searchLinkedByField, buildRelationshipTree, analyzeImpact, findBlockedIssues, detectCycles) |
|
| Conversational agent for admins (panel creation wizard, troubleshooting) | NO | OK (Message Panel Admin Agent: 23 admin actions, 6-step wizard, examples library, troubleshooting guides) | |
| Status summary aggregation across linked issues | NO | OK (getStatusSummary: groups by status category or status, with counts and percentages) |
|
| Search linked issues by field value | NO | OK (searchLinkedByField: operators equals / contains / in / not_in / gt / lt / gte / lte) |
|
| Impact analysis (downstream blocked issues) | NO | OK (analyzeImpact, findBlockedIssues) |
|
| Cycle detection in dependency graph | NO | OK (detectCycles) |
|
| Ready-to-use configuration patterns | NO | OK (getConfigExamples patterns: subtasks, blockers, epic, message-only, modal-warning, workload, release, security, jsm-portal-status, jql-same-labels, message-progress-bar) |
UI Modifications (Forge-only)
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Native Jira UI Modifications module | N/A (UIM is a Cloud-only platform feature) | OK (jira:uiModifications, key uim-logger) |
|
| Per-config Global Issue Create (GIC) UIM sync | N/A | OK (uim-sync-scheduler runs hourly, keeps per-config UI Modifications in sync with Jira field-context changes) |
JSM portal support
| Capability | DC | Forge | Notes |
|---|---|---|---|
| Render in JSM customer view (request detail) | OK (selectorViewSD CSS injection) |
OK (jiraServiceManagement:portalRequestDetailPanel) |
|
| Render in JSM create-request view | OK (selectorCreateSD CSS injection) |
OK (subheader and footer modules are registered on create_request page) |
|
| Render in JSM portal subheader (above request content) | NO | OK (jiraServiceManagement:portalSubheader, pages view_request + create_request) |
|
| Render in JSM portal footer (below request content) | NO | OK (jiraServiceManagement:portalFooter, pages view_request + create_request) |
|
| Filter by JSM request type | NO (filter at config level not natively, configurations live on the issue) | OK (filterSettings.requestTypes) |
|
| Visible to unlicensed Jira / customer-only portal users | OK (Service Desk customer model) | OK (unlicensedAccess: customer, unlicensed on all 3 portal modules) |
|
| Refined for Jira customer portal integration | OK (refinedcustomerportal web-resource context) |
NO |
Schedulers and background jobs (Forge)
On DC the plugin manifest declares no background tasks; rendering is on demand. Forge runs three scheduled triggers that DC users do not need (or that map to manual operations):
| Job | DC | Forge | Notes |
|---|---|---|---|
| Personal data report (GDPR) | N/A (DB-side responsibility) | OK (personal-data-report, weekly) |
|
| UIM sync (per-config GIC modifications follow Jira field-context changes) | N/A (UIM is Cloud-only) | OK (uim-sync-scheduler, hourly) |
|
| Custom field cleanup (detect deleted custom fields and contexts, disable orphaned configs) | N/A (DC has direct DB references that fail loud) | OK (custom-field-cleanup-scheduler, hourly) |
Unique features per version
Only in DC
- Custom JavaScript per configuration - each configuration carries a
codefield with browser-executed JS, plus a globalwhenRunJavaScriptswitch. Forge UI Kit forbids arbitrary client JS, so this is structurally unavailable on Cloud. - CSS-selector DOM injection -
selectorCreate,selectorView,selectorEdit,selectorTransition,selectorCreateSD,selectorViewSD. Lets a configuration land on any screen that exposes matching markup, including non-standard layouts and Refined for Jira portals. - Issue navigator column rendering (
column-view.vm) and XML export rendering (viewAsXml.vm) of the message field’s value. - Per-config color and icon theming -
backgroundColor,textColor,icon,iconColor(custom hex). Forge uses the fixedinfo / warning / error / success / changepalette instead. - Show only on create and status lists in the configuration -
showOnlyCreatehas no Forge counterpart. Status filters (statuses,dontShowStatuses) are stored as status ids in the DC configuration; Forge expresses the same through Display JQL (status in (...)/status not in (...)). - Group / role “show / hide” filters at configuration level -
groups,dontShowGroups,roles,dontShowRoles. Forge expresses the same intent through JQL and user-field filters. - Native time-window fields -
start/stopdates on the configuration. Forge expresses the same window with a template Display condition (isPast(...)/isFuture(...)). - Delegation to specific roles / groups / users -
delegatedRoles,delegatedGroups,delegatedUsersper configuration. Forge uses Jira’s native admin / project-admin condition. - Direct JVM access from templates -
$ComponentAccessorexposes an allowlist of 70+ Jira component getters (ProjectManager,IssueManager,UserManager,IssueLinkManager,WorkflowManager,FieldConfigSchemeManager,AvatarService,EventTypeManager, etc.). Forge runs on a sandboxed runtime where this is structurally unavailable. - Configuration audit log - a stored change history with its own REST endpoints and a dedicated admin page (
/secure/jibrokMessageFieldAuditLog). - REST API for configurations -
/rest/message-fieldand/rest/message-field-admin(v1.0). - 8 UI languages - en, de, es, fr, ja, pt, ru, zh.
- ScriptRunner Behaviours integration - documented integration patterns for using Message Field inside ScriptRunner Behaviours scripts, with timeout, default-message behavior, and JS execution-order settings (the dedicated admin page has been removed; these settings are reachable through the REST API).
- Statistics admin page - JQL performance dashboard with per-query validation, execution time, issue count, error / timeout flagging (250 ms warning, 5 s timeout); plus screen-usage analytics across Create / View / Edit screens, project coverage breakdown, and message-type distribution.
- Refined for Jira customer portal integration - explicit
customerportal,refinedcustomerportal, andcustomer-view-resources-contextweb-resource contexts. - Post-install and post-update onboarding pages -
jibrokMessageFieldPostInstall,jibrokMessageFieldPostUpdate.
Only in Forge
- Native issue panels - dedicated
jira:issuePanel,jira:issueActivity,jira:issueContext,jira:issueActionmodules render messages without requiring the field to be on every screen. - Modern message-render types -
plain_text,html,md(Markdown),adf(Atlassian Document Format). - Modal / dialog presentation -
showInModal,modalSize(small / medium / large / x-large),modalAppearance(warning / danger),modalAutoOpen,modalShowOncePerIssue(7 days), a flag on issue open (modalFlagOnOpen,modalFlagOpensModal), plus button text and appearance customization. - Severity wrappers -
messageWrapperType: info / warning / error / success / change / customwithmessageWrapperTitle. A semantic palette instead of arbitrary hex colors. - Configuration export / import - JSON-based,
bulkExportConfigurations/bulkImportConfigurations(up to 200 configs per import), withskipDuplicateNames. Used for site-to-site moves and backups. - Rovo AI agents - Message Panel Agent (end-user analytics over linked issues, 7 actions) and Message Panel Admin Agent (configuration wizard, troubleshooting, examples; 23 actions, 15 of them user-facing).
- Multi-level relationship tree and impact analysis -
buildRelationshipTree(1-5 levels),analyzeImpact(downstream impact),findBlockedIssues,detectCycles(1-10 levels). - JSM portal header, subheader and footer modules with
unlicensedAccess: customer, unlicensed. DC covers detail / create only. - JSM request-type filter at configuration level (
filterSettings.requestTypes). - User-field visibility filter as a first-class config field (
filterSettings.userFieldIds). - Pagination in the linked-issues table (
displaySettings.rowsPerPage, 1-100). - UI Modifications module and per-config GIC sync scheduler.
- Schedulers -
personal-data-report(GDPR, weekly),uim-sync-scheduler(hourly),custom-field-cleanup-scheduler(hourly, disables orphaned configs). - Configuration validators and health checks -
validateConfiguration,validateExistingConfig,healthCheck,findBrokenConfigs. Useful after Jira migrations. - Wizard-based configuration creation - 6 steps via
getWizardStep, mirrors the admin UI tabs. - Ready-to-use configuration patterns -
getConfigExamplesships subtasks, blockers, epic, modal-warning, workload, release, security, jsm-portal-status, jql-same-labels, message-progress-bar, and more. - Cache versioning for the browser-side config cache (data-version stamps on the global and per-project configuration caches).
Summary: picking the right version
- You’re on Data Center. Stay on DC if any of these are load-bearing for you: per-configuration custom JavaScript, ScriptRunner Behaviours integration, audit log of configuration changes, granular delegation to specific roles / groups / users,
dontShowGroups/dontShowRolesstyle “deny” filters, or one of the 6 non-English UI languages that the Forge app does not ship (es, fr, ja, pt, ru, zh). - You’re evaluating a move to Cloud. Forge covers the core of what most configurations need - per-project / per-issue-type / per-JSM-request-type targeting, JQL visibility filters, link-type and JQL-driven linked-issue tables, customer / unlicensed JSM portal access, modal presentation, Markdown / ADF / HTML rendering, configuration export / import, and a Rovo Admin Agent that walks you through creating each configuration. The two structural gaps to plan around are custom JavaScript per configuration (no Forge equivalent by platform design) and arbitrary CSS-selector injection (replaced by typed Forge modules).
- You’re standing up a fresh install. Forge is the recommended path for any Cloud deployment. There is no Cloud Connect Message Field; Forge is the only Cloud option.
Moving configurations from DC. Configurations move to Cloud with the Jira Cloud Migration Assistant (JCMA): install Message Field in the cloud site and put the Message Field custom field on a screen of every project whose configurations you want to migrate before you run the plan. Each DC field configuration becomes the configuration of the matching field context of the migrated field. A configuration is created enabled when everything in it can be expressed in the cloud; one that uses Velocity, custom JavaScript, CSS selectors, visibility by group, role or “view for”, delegation, a display condition that could not be translated, or a message over 20000 characters is created disabled, its description starting with
Disabled after migration: ...and the reason. To move only some messages, use Download for Jira Cloud in DC and import the file in Bulk Operations.After the migration, review the disabled configurations - see Migration from Data Center. The Forge admin agent and configuration examples library help you rebuild what did not move. If you need help with a large DC deployment, contact support.

