Project Management migration
Field-level mapping, validation, and rollback between Shotgun and Jira. We move data and schema; workflows are rebuilt natively in Jira.
Shotgun
Source
Jira
Destination
Compatibility
8 of 12
objects map 1:1 between Shotgun and Jira.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Shotgun to Jira is a schema remapping, not a direct record copy. Shotgun's entity model—Shots, Assets, Sequences, Tasks, Versions, Notes, and Pipeline Statuses—was designed for VFX and animation production pipelines and has no native Jira equivalent. Jira's data model is built for software development and enterprise project management using Projects, Issues, Epics, Stories, Tasks, and Subtasks. We bridge that gap by designing Jira custom Issue types that capture Shotgun entity types, mapping pipeline stages to Jira status workflows, and preserving version chains as ordered comment threads. We handle Shotgun's undocumented API rate limits with conservative batch sizing and exponential backoff, and we coordinate with the customer's admin to use a dedicated, non-deprovisioned integration account for authentication. Workflows, automations, and DCC tool integrations do not migrate; we deliver a written inventory of every active rule for the admin to rebuild in Jira.
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 Shotgun 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.
Shotgun
Project
Jira
Project
1:1Shotgun Projects map directly to Jira Projects. Project-level metadata including name, description, status, and pipeline configuration migrate as Project fields. We create Jira Projects via the Project resource endpoint before any entity migration begins so that Project keys are available for downstream issue creation. Studio-specific pipeline schema configurations that cannot be expressed as Jira Project settings are preserved as a written configuration inventory for the customer's admin.
Shotgun
Sequence
Jira
Epic
1:1Shotgun Sequences (editorial groupings of Shots) map to Jira Epic issues. The Epic's summary and description carry the Sequence name and notes. Epic issues are created before Shot-level migration so that the Epic key is available as a parent reference when Stories are created. Studios that do not use the Sequence entity may map Sequences to Jira Labels or custom field groupings instead; we confirm during scoping.
Shotgun
Shot
Jira
Story or Task (Epic-linked)
1:manyShotgun Shots map to Jira Stories linked to the parent Epic derived from the Shot's Sequence. Each Shot's cut_order, status, and assigned Tasks migrate as Story fields. Shot-level custom fields (cut_in, cut_out, head_duration, tail_duration) map to Jira custom fields of equivalent type. Shots without a Sequence parent map to Stories in a backlog Epic or a designated catch-all project. The Shot's Version chain is reconstructed as an ordered chain of comments on the Story, with version number, artist, and notes preserved.
Shotgun
Asset
Jira
Story or Task
1:1Shotgun Assets (characters, props, environments) map to Jira Stories or Tasks depending on the studio's asset tracking model. Asset type (Character, Prop, Environment, Vehicle) migrates as a Jira label or custom field. Asset thumbnails migrate as Jira issue attachments with a naming convention identifying them as the primary asset image. Assets without assigned Tasks are imported as Stories; Assets with Task assignments are imported as parent Stories containing Subtasks that correspond to the Asset Tasks.
Shotgun
Task
Jira
Task or Subtask
1:1Shotgun Tasks assigned to Shots or Assets map to Jira Subtasks linked to the parent Story. Task pipeline_stage, task_assignees, and task_status migrate as Subtask fields. Unassigned Tasks or Tasks that do not belong to a Shot or Asset parent map to Jira Tasks in the project backlog. Task dependencies (prev_task_entity, next_task_entity) map to Jira issue links (Blocks, Blocked by) if the destination Jira instance has the appropriate link type configured.
Shotgun
Version
Jira
Comment chain (Story-linked)
lossyShotgun Versions (iterations in the review pipeline) do not have a native Jira equivalent. We reconstruct the version chain as an ordered chain of Comments on the parent Story, each Comment containing the version number, version artist, version date, status, and review URL from Shotgun. Version approval status migrates as a Jira label or custom field on the Story. Studios with dedicated review workflows may choose to represent versions as Jira Labels for filtering rather than comments.
Shotgun
Note
Jira
Comment
1:1Shotgun Notes attached to Shots, Assets, or Tasks map to Jira Comments on the corresponding Story or Subtask. Shotgun's threaded Reply structure (where a Reply has a parent Note) is flattened in Jira: top-level Notes become Comments, and Replies become child Comments or replies via Jira's comment threading. Note author and timestamp migrate with each Comment. Shotgun's @mention syntax in Notes maps to Jira @mention in Comments if the mentioned user has a Jira account.
Shotgun
Attachment
Jira
Attachment
1:1Shotgun Attachments (uploaded files, render outputs, published media linked to Shots, Assets, or Versions) migrate as Jira issue attachments. We use Shotgun's get_attachment_download_url endpoint to retrieve attachment blobs and re-upload to Jira via the attachment endpoint. Attachment file size is constrained by Jira's attachment limits (the maximum file size varies by tier: 10 MB for Free, 250 MB for Standard and Premium Cloud). Large render outputs and video files that exceed Jira limits are flagged during scoping and linked as external URLs if the studio uses a DAM or storage system, or uploaded to Jira if within limits.
Shotgun
Thumbnail
Jira
Attachment
1:1Shotgun entity thumbnails (for Shots, Assets, Versions, and Tasks) migrate as Jira issue attachments with a thumbnail_ prefix in the filename. Jira does not have a native thumbnail display for issue avatars outside of the attachment list, so we attach thumbnails to the relevant Story with a note identifying them as the primary thumbnail for display purposes. Jira Premium offers issue property macros that can surface thumbnail attachments in issue detail views.
Shotgun
Pipeline Status
Jira
Status (via Status Category)
lossyShotgun pipeline statuses are studio-specific and vary widely between Shotgun sites. We extract the source site's pipeline workflow for each entity type (Shot, Asset, Task) and map each status value to a Jira Status within a Status Category (To Do, In Progress, Done). Any status with no Jira equivalent is flagged and escalated during scoping. Studios with multi-stage approval pipelines (e.g., wip, review, approved, omit) map to Jira status values plus Jira workflow transitions; we provide the status mapping matrix as a written deliverable.
Shotgun
Custom Field
Jira
Custom Field
lossyShotgun per-entity custom fields migrate to Jira custom fields of matching type (text, number, date, list, entity reference). Shotgun list fields (status picklists, type picklists) map to Jira select (single-choice) or multi-select fields. Entity reference fields (e.g., a custom field pointing to a Shot or Asset) map to Jira custom issue property or a Jira label. Custom field schemas vary between Shotgun sites, so we perform field-level mapping during the discovery phase before any data moves.
Shotgun
Tag/Label
Jira
Label
1:1Shotgun freeform Tags applied to any entity migrate to Jira Labels on the corresponding issue. Tags are stored as a flat list in Shotgun and Jira labels are a comma-separated field, so the migration is direct. Studios that use Tags for content classification (e.g., asset type, shot type, sequence category) should verify during scoping that Jira Labels provide sufficient filtering granularity for their post-migration workflow.
| Shotgun | Jira | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Sequence | Epic1:1 | Fully supported | |
| Shot | Story or Task (Epic-linked)1:many | Fully supported | |
| Asset | Story or Task1:1 | Fully supported | |
| Task | Task or Subtask1:1 | Fully supported | |
| Version | Comment chain (Story-linked)lossy | Fully supported | |
| Note | Comment1:1 | Fully supported | |
| Attachment | Attachment1:1 | Fully supported | |
| Thumbnail | Attachment1:1 | Fully supported | |
| Pipeline Status | Status (via Status Category)lossy | Fully supported | |
| Custom Field | Custom Fieldlossy | Fully supported | |
| Tag/Label | Label1:1 | Fully supported |
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.
Shotgun gotchas
Undocumented API rate limits cause migration failures
No bandwidth throttling on file attachment transfers
API authentication tied to individual user accounts
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 schema audit
We audit the source Shotgun site across entity types (Projects, Sequences, Shots, Assets, Tasks, Versions, Notes), custom field schemas (per-entity and cross-entity), pipeline status workflows, user accounts, and attachment inventory including file sizes and MIME types. We identify the Shotgun entity model that needs to be expressed in Jira and design the Jira custom Issue types, custom fields, and workflow statuses required to receive it. The discovery output is a written migration scope with an entity mapping matrix and a Jira configuration plan.
Jira project and workflow configuration
We create Jira Projects via the REST API (or import a Jira project configuration export), set up custom Issue types (e.g., Shot, Asset) if not already present, configure custom fields with types matched to Shotgun field types, and design the workflow statuses that correspond to the source Shotgun pipeline stages. We validate the Jira configuration in a sandbox or test environment before any production data moves, confirming that issue creation, attachment upload, and comment threading behave as expected.
Credential and API preparation
We confirm that a dedicated, non-deprovisioned Shotgun integration account is available for the migration session, and that the account has read access to all Projects, entity types, and attachments being migrated. We test the Shotgun API session and measure current rate limit behavior with a small batch of find queries to calibrate our batch sizing and backoff strategy before running large-scale entity reads.
Sandbox migration and reconciliation
We run a full migration into a Jira test environment using production-like data volume. The customer's production coordinator and project manager reconcile entity counts (Projects in, Sequences in, Shots in, Assets in, Tasks in), spot-check 25-50 randomly selected Shots and Assets against the Shotgun source, and verify that version chains, notes, and attachments are correctly associated. The customer signs off the mapping before production migration begins. Any corrections to custom field mapping, status mapping, or parent-child resolution happen in the test environment.
Production migration in dependency order
We run production migration in entity dependency order: Projects first, then Sequences (to Epics), Shots (to Epic-linked Stories), Assets (to Stories or Tasks), Tasks (to Subtasks), followed by Notes as Comments, Attachments as Jira attachments, and version chains as ordered Comment threads. Each phase emits a row-count reconciliation report before the next phase begins. Shotgun API batch reads run with conservative sizing and exponential backoff throughout. We flag any records that fail due to required field nulls or attachment size violations for customer-admin resolution before resuming.
Cutover, validation, and workflow rebuild handoff
We freeze Shotgun write activity during the cutover window, run a final delta migration of any records modified during the migration run, then enable Jira as the system of record. We deliver a written inventory of every Shotgun pipeline status workflow, automation rule, and DCC tool integration that requires rebuild in Jira (or in a Jira-compatible add-on). We support a one-week hypercare window for reconciliation issues. We do not rebuild Shotgun pipeline configurations as Jira workflows inside the migration scope; that is a separate engagement for the customer's admin team or an Atlassian partner.
Platform deep dives
Shotgun
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 Shotgun 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
Shotgun: Not publicly documented. Community reports confirm quota enforcement at the authorization endpoint with no self-service visibility into current usage..
Data volume sensitivity
Shotgun 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 Shotgun to Jira migration scoping. Not seeing yours? Book a call.
Walk through your Shotgun 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 Shotgun
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.