- 1. How the transfer works
- 2. What transfers
- 3. What does not transfer - and why the numbers still match
- 4. Where the payload lands: the Forge PRODUCTION environment
- 5. The migration does not hang
- 6. Known limits and what we have not verified
- 7. After you migrate: fields and bindings
- 8. Before and after you migrate: checklist
- Where to go next
Two questions come back on almost every Data Center → Cloud migration of this app:
- “Do we have to recreate the configuration by hand in Cloud?” - No. The Jira Cloud Migration Assistant (JCMA) carries the app’s settings for you.
- “Why did the values not come across?” - They are not supposed to. Time in Status, Timer and Stopwatch values are derived from the issue history. JCMA migrates the history; the Cloud app computes the same numbers from it.
This page is the reference for what is inside the transfer and what is not. The end-to-end procedure - JCMA run, field creation, config bindings - is on the Migration from Data Center to Forge Cloud protocol page.
| Travels with JCMA | Recreated in Cloud | |
|---|---|---|
| App settings - calendars, configurations, schemes, events, bindings | Yes, automatically - but they arrive not bound to fields | Bind them in Health Check |
| Jira custom fields | No - the Time in Status, Timer and Stopwatch fields are not created in Cloud | Create them by hand or with Step 2 of the protocol |
| Per-issue values - accumulated time, live timer state, action history | No, by design | Computed from the migrated issue history |
The full list of what stays behind is under What does not migrate; the order of work is in the checklist.
1. How the transfer works
The Data Center app registers a migration listener that implements Atlassian’s ForgeAppMigrationListener interface. JCMA discovers listeners by that interface name, so there is nothing to configure on the Data Center side: install or upgrade the app, mark it as Needed in cloud in the migration plan, and run the migration. When JCMA reaches the app-data phase it calls the listener, the app assembles its settings, and the payload is uploaded to the Cloud app.
The self-check line in the log
Every time the plugin starts, it verifies that its listener is actually visible to JCMA and writes the result to atlassian-jira.log under MigrationListenerSelfCheck. There are exactly two outcomes:
| Level | What the line says | What it means |
|---|---|---|
INFO |
the listener is registered under ...DiscoverableForgeListener |
JCMA can see the listener. The app will be offered in the migration plan and will produce a payload. |
WARN |
the reason the listener is not visible | JCMA cannot see the listener. The migration will still run, but this app contributes nothing to it. |
Find it with:
grep MigrationListenerSelfCheck /var/atlassian/application-data/jira/log/atlassian-jira.log
WARN line names the reason. On a cluster, check the node that actually ran the migration.
The line is written at plugin startup, not at migration time, so it is already in the log before you start the migration. Check it while you are still planning - not after the maintenance window.
Fields that are on no screen
As of 6.6 the same startup self-check - and the export itself - lists the Time in Status, Timer, Stopwatch and Calendar fields that are not on any screen. They are written to atlassian-jira.log as WARN lines and repeated in the export warnings. JCMA does not migrate such fields: put each of them on a screen of a project you migrate before you run the migration.
2. What transfers
The app collects the following into the JCMA payload. All of it arrives in Cloud without re-entry - the one manual step is attaching the settings to the Cloud fields (After you migrate):
| Setting | What is included |
|---|---|
| Work calendars | Working hours, breaks and the role assignments of the calendar |
| Custom events | The named trigger rules used by Timer and Stopwatch configurations |
| Time in Status configurations | The selected statuses, the work calendar the configuration uses, and the JQL condition |
| Panel configurations | The configurations behind the issue panels |
| Timer schemes | The schemes together with their goals and field settings |
| Stopwatch schemes | The schemes together with their goals and field settings |
| Field bindings | Which configuration applies where - global bindings, per-project bindings and per-issue-type bindings. The Cloud fields do not exist yet when the settings arrive, so the settings are not attached to fields - bind them in Health Check |
JCMA also remaps the IDs that differ between the two instances (statuses, projects, issue types), so calendars, configurations and bindings arrive already referencing valid Cloud IDs.
Field type mapping
Each binding names the Cloud field type it belongs to. The Data Center field types map onto the Forge ones like this:
| Data Center field | Cloud (Forge) field type |
|---|---|
| Time in Status | tis-custom-field |
| Timer | tmr-custom-field |
| Stopwatch | sw-custom-field |
The payload therefore knows which Cloud field each configuration is for - but the Jira custom fields themselves still have to exist on the Cloud site. Creating them is Step 2 of the protocol; a few Data Center field types have no Cloud equivalent at all and are listed under Unsupported field types.
3. What does not transfer - and why the numbers still match
Nothing that is stored per issue travels with the app migration:
- Accumulated time - the values shown in the Time in Status, Timer and Stopwatch fields on each issue.
- The live state of a running timer or stopwatch - a timer that is running in Data Center does not arrive running in Cloud.
- The action history - the per-issue record of starts, pauses, stops and restarts.
This is by design, not a gap. These fields are derived values: the app computes them from the issue’s own change history. JCMA migrates that history as part of the ordinary issue migration, so the raw material the numbers are made of is already on the Cloud site. Given the same configuration and the same history, the Cloud app arrives at the same numbers - copying the values across would only add a second source of truth that could drift from the first.
What does not migrate
Plan for these before the maintenance window - none of them arrives in Cloud, whatever the migration reports:
| What | What happens in Cloud | What you do |
|---|---|---|
| Fields with no Cloud counterpart - Transition counter, Is status, the JQL function and the helper fields of Time in Status | They do not appear in Cloud | Nothing to migrate; see Unsupported field types for the replacements |
| Per-issue data - running timers and stopwatches, the history of manual actions | Not transferred; values are recomputed from the issue history | Recalculate after the fields are bound |
| Reports and their permissions | Not transferred | Check the feature comparison for what Cloud offers, then set up what you need again |
| Timer goal notifications | Not transferred | Check the feature comparison, then set up what you need again |
| Manual control of Timer and Stopwatch - start, pause, stop and restart by hand | Not transferred | Check the feature comparison, then set up what you need again |
| Permissions and reports of the Time in Status panel | Not transferred | Check the feature comparison, then set up what you need again |
| The Jira custom fields themselves | Not created; the imported settings arrive unbound | Create the fields and bind the settings |
Per-field checklist: what has to match for the numbers to match
The first three rows travel with the configuration (see What transfers); the fourth is the history the numbers are computed from, which JCMA migrates with the issues. So this checklist is not work you have to redo - it is how you confirm, one field at a time, that what arrived is what you had, when a number in Cloud does not look like the number in Data Center.
| What has to match | Where you compare it | Why it changes the number |
|---|---|---|
| Selected statuses | DC: the list of tracked statuses on the field configuration Cloud: the field setting bound to the context |
A status that is tracked on one side and not on the other changes the total directly. |
| Work calendar | DC: the calendar the configuration uses - working hours, breaks, holidays, timezone Cloud: the calendar the field setting uses |
Only working time is counted. A different calendar - or the same calendar in a different timezone - produces a different number from identical history. |
| JQL condition | DC: the condition on the configuration Cloud: the condition on the field setting |
The condition decides whether the issue is counted at all. An issue that fails it has no value, not a zero. |
| Issue history | DC: the issue’s History tab Cloud: the same tab on the migrated issue |
The numbers are computed from it. If issues were migrated without their history, or the issue was created in Cloud after the migration, there is nothing to compute from. |
Work the list top to bottom on one issue whose number looks wrong before you touch anything global: three of the four rows are visible in the field setting itself, and the fourth is visible in the issue’s History tab.
What the export warns about (as of 6.6)
As of 6.6 the export no longer leaves out settings silently. For each group of settings that cannot be carried to Cloud - fields with no Cloud counterpart, Timer goal notifications, panel permissions and reports, and so on - it writes a warning with the count and the names of what was left out. The warnings are in the JCMA log of the migration.
Two kinds of settings new in 6.6 are among them, each with a warning of its own:
- Timer goals with a deadline field - goals that take their deadline from Due date or a date field (Deadline from a date field) are not transferred.
- Time between statuses fields - the field has no counterpart in Cloud and is not transferred (Time between statuses field).
Fields that are on no screen are named in the warnings too - see Fields that are on no screen.
Two settings travel as of 6.6 that did not before: the Show as panel flag of Timer and Stopwatch fields - the panels are created in Cloud - and the order of statuses in Time in Status configurations.
4. Where the payload lands: the Forge PRODUCTION environment
The export is delivered to the PRODUCTION environment of the Cloud app - the environment you get when you install Time in Status from the Atlassian Marketplace. No action is needed on your side; this is simply where the data goes.
6.5.1-jira10 for Jira 10.x, 6.5.1-jira11.3 for Jira 11.3 - or later.
5. The migration does not hang
The app always signals the end of its export back to JCMA - completeExport() is called on every path, including the failing ones. Two consequences worth knowing before you plan a maintenance window:
- A failure inside the app does not leave the migration in running. JCMA gets its terminating signal and the migration reaches a final state.
- A failure before any data starts flowing is marked in the log. If the app fails before the data stream starts, it writes a warning marker to
atlassian-jira.logand completes the export anyway.
So a migration that finished but delivered nothing is a question for the log, not a stuck job. Read the MigrationListenerSelfCheck line first, then look for the warning marker around the time of the run.
6. Known limits and what we have not verified
The migration was last run end to end on 08.10.2026: Jira 10.3.15 with JCMA 1.27.0 and Time in Status DC 6.5.1, into Time in Status for Jira Cloud (Forge) 3.48.0. Earlier, the migration listener was confirmed working on Jira 10.7.x and Jira 11.3 with JCMA 1.12.30. Everything outside that is untested rather than known-broken:
| Area | Verified | Not verified |
|---|---|---|
| Jira Data Center version | 10.3.15 (08.10.2026), 10.7.x, 11.3 | The rest of the 10.x line |
| JCMA version | 1.27.0 (08.10.2026), 1.12.30 | Other JCMA versions published on the Marketplace, including versions between 1.12.30 and 1.27.0 and newer than 1.27.0 |
| Time in Status DC → Cloud | 6.5.1 → Forge 3.48.0 (08.10.2026) | Other pairs of builds |
Fallback: migrate the configuration by hand
If the listener cannot be made visible to JCMA on your instance, the migration does not have to wait for it:
- In the JCMA migration plan, mark Time in status / SLA / Timer / Stopwatch as Not needed in cloud, so the plan does not carry the app.
- Migrate projects, issues and history as usual - the history is what the Cloud values are computed from, and it moves independently of the app.
- Bring the configuration over yourself: either the JSON export / import path from the Data Center Migration page, or by recreating the calendars and field settings in the Cloud admin.
- Continue with the protocol as normal - create the fields, bind the configs, then recalculate.
Status IDs are not remapped on the JSON path, which is the one thing JCMA does for free. Check the tracked statuses on each imported configuration before you trust the first numbers.
7. After you migrate: fields and bindings
On Data Center 6.5.1 with the Cloud app 3.48.0, JCMA carries the Time in Status settings - field configurations, Timer and Stopwatch schemes - but it does not create the Time in Status fields in Cloud, and the imported settings arrive not bound to any field. Until both are fixed, the Cloud fields show nothing.
- Create the fields in Cloud. Go to Jira settings → Fields → Create field and create one field for each Data Center field you migrate, with the type Time in Status, Timer or Stopwatch - the same name as in Data Center makes the binding step easier. Put each field on the screens of the migrated projects. To create many fields at once, use the generated script from Step 2 of the protocol instead.
- Bind the imported settings in Health Check. Open Apps → Time in Status → Health Check. It lists the field contexts that have no setting yet; bind each of them to the imported configuration or scheme it had in Data Center. For many contexts, the binding manifest does the same in one pass.
- Run a full recalculation. Once every context is bound, run a full recalculation so the values are computed from the migrated issue history.
Check Health Check once more after the recalculation: an unbound context left behind is a field that stays empty.
8. Before and after you migrate: checklist
Before you run the migration plan
- The Data Center app is on 6.5.0 or later - 6.5.1 recommended (why).
- The Cloud app is installed from the Marketplace listing Time in Status - the full app, not Timer, Stopwatch or Time between dates. Only the full Time in Status listing accepts the data from Data Center.
- The Cloud app is installed before you start the JCMA plan. The event with the app data is not delivered a second time: if the app is missing when it is sent, the plan hangs and fails on a timeout.
- Every Time in Status, Timer, Stopwatch and Calendar field you need is on a screen of a project you migrate. JCMA does not create fields that are on no screen (Fields that are on no screen).
- The
MigrationListenerSelfCheckline inatlassian-jira.logisINFO(The self-check line). - You know what does not migrate and have a plan for it (What does not migrate).
After the migration
- The Time in Status, Timer and Stopwatch fields exist in Cloud (step 1).
- Health Check shows every context bound to its imported setting (step 2).
- A full recalculation has run, and a few issues show the same numbers as in Data Center (per-field checklist).
Where to go next
- Migration from Data Center to Forge Cloud - the full step-by-step protocol from the Data Center side.
- Migration to Time in Status (Forge) - the Cloud-side companion.
- Where the fields are used - the inventory to take before the migration and verify against afterwards.
- DC / Connect / Forge feature comparison - what changes for your admins and users after the move.

