Message Field - DC / Forge feature comparison


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 field custom 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 *WithCheckPermissions versions 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.)

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

  1. Custom JavaScript per configuration - each configuration carries a code field with browser-executed JS, plus a global whenRunJavaScript switch. Forge UI Kit forbids arbitrary client JS, so this is structurally unavailable on Cloud.
  2. 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.
  3. Issue navigator column rendering (column-view.vm) and XML export rendering (viewAsXml.vm) of the message field’s value.
  4. Per-config color and icon theming - backgroundColor, textColor, icon, iconColor (custom hex). Forge uses the fixed info / warning / error / success / change palette instead.
  5. Show only on create and status lists in the configuration - showOnlyCreate has 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 (...)).
  6. Group / role “show / hide” filters at configuration level - groups, dontShowGroups, roles, dontShowRoles. Forge expresses the same intent through JQL and user-field filters.
  7. Native time-window fields - start / stop dates on the configuration. Forge expresses the same window with a template Display condition (isPast(...) / isFuture(...)).
  8. Delegation to specific roles / groups / users - delegatedRoles, delegatedGroups, delegatedUsers per configuration. Forge uses Jira’s native admin / project-admin condition.
  9. Direct JVM access from templates - $ComponentAccessor exposes 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.
  10. Configuration audit log - a stored change history with its own REST endpoints and a dedicated admin page (/secure/jibrokMessageFieldAuditLog).
  11. REST API for configurations - /rest/message-field and /rest/message-field-admin (v1.0).
  12. 8 UI languages - en, de, es, fr, ja, pt, ru, zh.
  13. 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).
  14. 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.
  15. Refined for Jira customer portal integration - explicit customerportal, refinedcustomerportal, and customer-view-resources-context web-resource contexts.
  16. Post-install and post-update onboarding pages - jibrokMessageFieldPostInstall, jibrokMessageFieldPostUpdate.

Only in Forge

  1. Native issue panels - dedicated jira:issuePanel, jira:issueActivity, jira:issueContext, jira:issueAction modules render messages without requiring the field to be on every screen.
  2. Modern message-render types - plain_text, html, md (Markdown), adf (Atlassian Document Format).
  3. 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.
  4. Severity wrappers - messageWrapperType: info / warning / error / success / change / custom with messageWrapperTitle. A semantic palette instead of arbitrary hex colors.
  5. Configuration export / import - JSON-based, bulkExportConfigurations / bulkImportConfigurations (up to 200 configs per import), with skipDuplicateNames. Used for site-to-site moves and backups.
  6. 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).
  7. Multi-level relationship tree and impact analysis - buildRelationshipTree (1-5 levels), analyzeImpact (downstream impact), findBlockedIssues, detectCycles (1-10 levels).
  8. JSM portal header, subheader and footer modules with unlicensedAccess: customer, unlicensed. DC covers detail / create only.
  9. JSM request-type filter at configuration level (filterSettings.requestTypes).
  10. User-field visibility filter as a first-class config field (filterSettings.userFieldIds).
  11. Pagination in the linked-issues table (displaySettings.rowsPerPage, 1-100).
  12. UI Modifications module and per-config GIC sync scheduler.
  13. Schedulers - personal-data-report (GDPR, weekly), uim-sync-scheduler (hourly), custom-field-cleanup-scheduler (hourly, disables orphaned configs).
  14. Configuration validators and health checks - validateConfiguration, validateExistingConfig, healthCheck, findBrokenConfigs. Useful after Jira migrations.
  15. Wizard-based configuration creation - 6 steps via getWizardStep, mirrors the admin UI tabs.
  16. Ready-to-use configuration patterns - getConfigExamples ships subtasks, blockers, epic, modal-warning, workload, release, security, jsm-portal-status, jql-same-labels, message-progress-bar, and more.
  17. 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 / dontShowRoles style “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.