Project Management migration
Field-level mapping, validation, and rollback between Exepron and Jira. We move data and schema; workflows are rebuilt natively in Jira.
Exepron
Source
Jira
Destination
Compatibility
9 of 12
objects map 1:1 between Exepron and Jira.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Exepron to Jira is a methodology and data-model migration. Exepron uses Critical Chain Project Management with Work Packages, Activities, Resource Drums, and AI-generated buffer analytics (BIDSS); Jira uses an Issue-based agile model with Epics, Stories, Tasks, and Sub-tasks. There is no native Critical Chain concept in Jira, so predecessor chains migrate as Jira dependency links and buffer metrics migrate as custom fields. BIDSS dashboards and PALS training records are runtime-generated artefacts with no persistent export; we explicitly exclude them from scope and deliver a written inventory for the customer's admin to rebuild in a BI tool. We map Activity Bundles to Jira Epics, Project Templates to Jira Project Templates, and Resource Types to Project Roles, with Earned Value snapshots captured as point-in-time custom field values at migration time.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Exepron object lands in Jira, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Exepron
Project
Jira
Project
1:1Exepron Projects map directly to Jira Projects. We export project metadata (name, status, start/finish dates, priority) via GET /projects and create corresponding Jira Projects during migration. If the source Exepron account uses multiple concurrent project portfolios, we recommend one Jira Project per Exepron project or one Jira Project per portfolio, depending on the customer's reporting structure. Jira Project keys (e.g., ENG, MKT) are derived from the project name during scoping.
Exepron
Activity
Jira
Issue (Story, Task, or Sub-task)
1:1Exepron Activities map to Jira Issues. Task Name becomes Summary, Duration and Start/Finish dates map to Due Date and a custom duration field. Activity Kanban statuses and Custom Activity Statuses are mapped to Jira Status values in the destination workflow scheme. For Activities with parent Work Packages, we set the Jira Epic Link custom field or nest as Stories under the parent Epic. Fixed-duration flags migrate as a custom field; Jira treats all issues as variable duration by default.
Exepron
Predecessors
Jira
Issue Links (Blocks / Depends on)
1:1Exepron predecessor chains (Finish-to-Start by default) migrate to Jira Issue Links. We use the Jira issue-links REST API to create dependency records after both the source and destination issues exist. The predecessor sequence in Exepron is preserved as the link type and order. Jira does not support buffer insertion between linked issues; we capture buffer duration as a custom field (ccpm_buffer_duration__c) and document the original buffer position in the migration notes for the customer's admin to address in project planning.
Exepron
Resource
Jira
User (assignee)
1:1Exepron Resources (people, equipment, facilities) map to Jira Users by resolving the resource name or email against the Jira instance user directory. If a Resource has no corresponding Jira User, we hold it in a reconciliation queue for the customer's Jira admin to provision. Resource Capacity and Consumption units are stored as custom fields on the mapped Issue because Jira does not have a native resource capacity model.
Exepron
Resource Type
Jira
Project Role
lossyExepron Resource Types (grouping Resources for drum scheduling) map to Jira Project Roles. We export the type hierarchy from Exepron and create corresponding Project Roles in Jira (e.g., Developer, Designer, QA Lead). Resource assignments in Exepron become Jira Issue Assignees scoped to the appropriate Project Role. The Dynamic Drum recommendation is not migratable as an artefact; we preserve the drum recommendation timestamp and constraint window in a custom field for manual re-entry in Jira.
Exepron
Activity Bundle
Jira
Epic
1:1Exepron Activity Bundles (grouping related Activities under a Work Package) map to Jira Epics. We export the bundle hierarchy and create Jira Epics in the destination project. Child Activities become Stories linked to the Epic via the Epic Link custom field. If Activities span multiple Exepron Projects, we use Jira's Cross-Project Epic Links or restructure into a single parent Epic with Stories distributed across the relevant Jira Projects during scoping.
Exepron
Custom Fields
Jira
Custom Fields
1:1Exepron Custom Fields map to Jira Custom Fields of the closest matching type (text, number, date, select). We export field definitions and values from Exepron and pre-create the corresponding Jira custom fields in the destination project before import. Multi-select custom fields in Exepron map to Jira multi-select or checkboxes. Custom field contexts (project-level vs. global) are preserved. Jira's custom field scoping model differs from Exepron's per-account model; we configure contexts during schema design.
Exepron
Project Template
Jira
Project Template
1:1Exepron Project Templates (reusable task networks with resource assignments) map to Jira Project Templates. We export the template block structure and task sequence from Exepron and use Jira's Project Template feature to pre-populate new projects. Template Blocks are supported but require manual reconstruction in Jira because Jira Project Templates do not preserve a full Activity hierarchy; we document the block structure as a handoff artifact for the customer's admin to use when creating new projects from template.
Exepron
Custom Roles
Jira
Project Roles + Permission Schemes
lossyExepron Custom Roles (permission scoping within Exepron) map to Jira Project Roles and Permission Schemes. We export the role definition and permission set from Exepron and map to the nearest Jira permission category (Browse Projects, Create Issues, Assign Issues, etc.). Exepron-specific permission concepts (e.g., portfolio-level access, BIDSS access) have no direct Jira equivalent; we flag these in the permission mapping document and recommend Jira administrators use Jira administrators, project administrators, and site-wide access levels to approximate.
Exepron
Earned Value records
Jira
Custom fields (PV, EV, AC)
1:1Exepron Earned Value Module (Planned Value, Earned Value, Actual Cost per task) migrates as point-in-time custom fields on the mapped Jira Issues. We export the EV snapshot values at migration time and create numeric custom fields (exepron_ev__c, exepron_pv__c, exepron_ac__c) in Jira. Because EV is calculated at migration time and Jira does not natively update EV after cutover, we flag this as a historical snapshot rather than a live metric. The customer's admin rebuilds EV tracking using a Jira marketplace app or external BI tool if ongoing EV reporting is required.
Exepron
What-If Analysis Projects
Jira
Jira Automation rules or manual reconstruction
lossyExepron What-If scenarios (cloned projects with modified constraints, durations, or resource loads) are exported as separate Jira Projects with a naming convention that flags them as scenario variants (e.g., PROJ-WhatIf-A, PROJ-WhatIf-B). The delta changes (modified durations, resource loads, start date shifts) are captured in a custom field (exepron_scenario_delta__c) as JSON. Jira does not natively support What-If scenario modeling; the customer's admin rebuilds this using Jira Automation, Structure ( marketplace app), or a third-party scheduling tool.
Exepron
Alerts and Reason Codes
Jira
Labels or custom fields
1:1Exepron Alerts (threshold-based notifications for task slippage and resource overload) and Reason Codes (annotations for why slips occurred) migrate as Jira Labels or custom select fields. We export the alert definitions and reason code values and map them to Jira Labels (preferred for cross-issue reporting) or to a custom Status Category + custom field if the customer requires structured reason-code tracking. Alert trigger thresholds are not migratable as live rules; we document them for the customer's admin to reconstruct as Jira Automation rules.
| Exepron | Jira | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Activity | Issue (Story, Task, or Sub-task)1:1 | Fully supported | |
| Predecessors | Issue Links (Blocks / Depends on)1:1 | Fully supported | |
| Resource | User (assignee)1:1 | Fully supported | |
| Resource Type | Project Rolelossy | Fully supported | |
| Activity Bundle | Epic1:1 | Fully supported | |
| Custom Fields | Custom Fields1:1 | Mapping required | |
| Project Template | Project Template1:1 | Fully supported | |
| Custom Roles | Project Roles + Permission Schemeslossy | Mapping required | |
| Earned Value records | Custom fields (PV, EV, AC)1:1 | Mapping required | |
| What-If Analysis Projects | Jira Automation rules or manual reconstructionlossy | Mapping required | |
| Alerts and Reason Codes | Labels or custom fields1:1 | Mapping required |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Exepron gotchas
API uses placeholder URLs that must be replaced
API scopes and token expiry are not publicly documented
MS Project import requires exact column sequence
BIDSS and PALS have no persistent export artefacts
No prorated refunds on cancellation
Jira gotchas
Unsupported workflow validators silently skipped during migration
Custom fields converted to flat text labels when migrating to non-Jira platforms
Historical status-change timestamps lost when exporting without a Marketplace plugin
Attachment import failures from oversized files and JQL reference corruption
Points-based API rate limits enforced on Jira Cloud apps from March 2026
Pair-specific challenges
Migration approach
Discovery and Exepron API endpoint validation
We audit the source Exepron instance to inventory all Projects, Activities, Activity Bundles, Resources, Resource Types, Custom Fields, Project Templates, Custom Roles, and any active What-If Analysis Projects. We obtain the customer's actual Identity Server and API Server URLs during scoping (replacing the documented placeholders), validate OAuth 2.0 connectivity with both standard and extended scopes, and run a test export to confirm data completeness. We also confirm the Exepron plan tier (Standard/Pro/Enterprise) because API access and extended scopes require Pro or above.
Jira project structure and Epic-Story hierarchy design
We design the Jira destination schema based on the Exepron inventory. Each Exepron Project becomes a Jira Project with a derived Project Key. Activity Bundles become Jira Epics; Activities become Stories or Tasks linked to the relevant Epic. Resource Types map to Jira Project Roles. Custom Fields are pre-created with matching types (text, number, date, select). We define the workflow scheme (Kanban or Scrum) and configure status-to-Exepron-status mappings. If the customer requires Cross-Project Epics or shared Epic structures across Jira Projects, we configure these during this step. Schema is deployed to a Jira Sandbox for validation before any data loads.
Sandbox migration and dependency resolution
We run a full migration into Jira Sandbox using representative data volume. Predecessor chains are resolved by creating Jira Issue Links after both source and destination issues exist. Activity Bundles are restructured into Epic-Story hierarchies and validated against the original Exepron bundle scope. Resource assignments are mapped to Jira Users via email resolution. Custom fields are validated for type correctness and context scoping. The customer's project manager and Jira admin review 25-50 randomly sampled issues and sign off the mapping before production migration. Any dependency restructuring, custom field corrections, or Epic-link changes happen here.
Earned Value and Alert reconciliation
We extract Earned Value snapshots (PV, EV, AC) from Exepron at migration time and populate Jira custom fields as static values. We document the alert threshold definitions and reason codes from Exepron in a written handoff sheet. What-If scenario deltas are captured as JSON in a custom field on the corresponding Jira Projects. The customer reviews the EV snapshot and alert definitions and confirms which thresholds require rebuild as Jira Automation rules. This step produces the Written Artefacts document that FlitStack AI delivers as standard scope.
Production migration in dependency order
We run production migration in record-dependency order: Jira Projects (created first), Project Roles (provisioned), Custom Fields (deployed), then Activities with Work Package hierarchy resolved into Epic-Story structures. Predecessor chains are inserted as Jira Issue Links after parent issues are confirmed. Resource assignments map to Jira Assignees. Custom field values, Activity statuses, and template block structures are migrated in sequence. Each phase emits a row-count reconciliation report before the next phase begins. BIDSS and PALS are excluded from the migration manifest and noted as non-transferable in the final handoff.
Cutover, board filter validation, and handoff
We freeze Exepron writes during the cutover window, run a final delta migration for any records modified during the migration window, then enable Jira as the system of record. We validate Jira board filters against the migrated Epic-Story structure and document any filter updates required. We deliver the Written Artefacts document covering BIDSS non-transfer, PALS non-transfer, alert threshold rebuild recommendations, What-If scenario delta notes, and EV snapshot metadata. We support a one-week hypercare window for reconciliation issues. Workflow and automation rebuild (if any) is outside standard scope and documented for the customer's Jira admin.
Platform deep dives
Exepron
Source
Strengths
Weaknesses
Jira
Destination
Strengths
Weaknesses
Complexity grading
Standard Project Management migration. 3 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Exepron and Jira.
Object compatibility
3 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Exepron: Not publicly documented.
Data volume sensitivity
Exepron doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Exepron to Jira migration scoping. Not seeing yours? Book a call.
Walk through your Exepron to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Exepron
Other ways to arrive at Jira
Same-Project Management migrations
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.