Project Management migration

Migrate from Shotgun to Jira

Field-level mapping, validation, and rollback between Shotgun and Jira. We move data and schema; workflows are rebuilt natively in Jira.

Shotgun logo

Shotgun

Source

Jira

Destination

Jira logo

Compatibility

67%

8 of 12

objects map 1:1 between Shotgun and Jira.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Shotgun logo

Shotgun

What's pushing teams away

  • Undocumented API rate limits cause production-scoped migration scripts to fail silently or return 429 errors without warning.
  • Studios outgrow the per-seat pricing model as crew sizes grow, prompting evaluation of in-house or open-source alternatives.
  • Limited offline and mobile access frustrates production coordinators working from sets or locations without reliable connectivity.
  • Performance degrades noticeably on Projects containing tens of thousands of Task or Shot records, particularly in the web UI.
  • Authentication is tied to individual user accounts with no API-key or service-account model, making automated migrations brittle.

Choosing

Jira logo

Jira

What's pulling them in

  • Industry-standard tool with deep Git integration and sprint reporting that engineering teams already know, reducing onboarding friction for new hires.
  • Highly customizable workflows and status schemes let business teams model complex approval chains without writing code.
  • Strong ecosystem of Atlassian Marketplace apps means specialized capabilities like time tracking or portfolio management are one install away.
  • Free tier with up to 10 users and unlimited issues gives small teams a no-cost entry point to validate the platform before committing budget.
  • Visibility features — boards, backlog grooming, sprint reports, and dashboards — give leadership a shared view of what is planned, in progress, blocked, and done.

Object mapping

How Shotgun objects map to Jira

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

maps to

Jira

Project

1:1
Fully supported

Shotgun 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

maps to

Jira

Epic

1:1
Fully supported

Shotgun 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

maps to

Jira

Story or Task (Epic-linked)

1:many
Fully supported

Shotgun 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

maps to

Jira

Story or Task

1:1
Fully supported

Shotgun 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

maps to

Jira

Task or Subtask

1:1
Fully supported

Shotgun 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

maps to

Jira

Comment chain (Story-linked)

lossy
Fully supported

Shotgun 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

maps to

Jira

Comment

1:1
Fully supported

Shotgun 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

maps to

Jira

Attachment

1:1
Fully supported

Shotgun 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

maps to

Jira

Attachment

1:1
Fully supported

Shotgun 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

maps to

Jira

Status (via Status Category)

lossy
Fully supported

Shotgun 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

maps to

Jira

Custom Field

lossy
Fully supported

Shotgun 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

maps to

Jira

Label

1:1
Fully supported

Shotgun 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.

Gotchas + challenges

What specifically takes care here

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 logo

Shotgun gotchas

High

Undocumented API rate limits cause migration failures

Medium

No bandwidth throttling on file attachment transfers

High

API authentication tied to individual user accounts

Jira logo

Jira gotchas

High

Unsupported workflow validators silently skipped during migration

High

Custom fields converted to flat text labels when migrating to non-Jira platforms

Medium

Historical status-change timestamps lost when exporting without a Marketplace plugin

Medium

Attachment import failures from oversized files and JQL reference corruption

Medium

Points-based API rate limits enforced on Jira Cloud apps from March 2026

Pair-specific challenges

  • Shotgun entity types have no native Jira equivalent

    Shotgun's core entity model (Shots, Assets, Sequences, Versions) was designed for VFX and animation production pipelines and does not map to any native Jira object. Jira has no concept of a Version chain, a cut order, or an Asset entity with a thumbnail. We handle this by designing custom Jira Issue types (e.g., Shot, Asset) with custom fields that capture Shotgun-specific attributes, and by reconstructing version chains as ordered comment threads. Studios should expect that the Jira representation of a Shot will look structurally different from the Shotgun Shot detail view, and that post-migration user training will be required for coordinators transitioning to the Jira interface.

  • Undocumented Shotgun API rate limits force conservative batch sizing

    Shotgun's API rate limits are not published, which means we cannot determine the exact ceiling before a migration begins. Community reports confirm that quota errors occur without warning and that there is no self-service dashboard to monitor current usage. We implement conservative batch sizing (typically 50-100 records per request) and exponential backoff to avoid triggering limits, which extends migration windows. Studios with large Projects containing tens of thousands of Tasks or Shots should plan for longer migration timelines and should freeze write activity during migration windows to reduce API load.

  • API authentication tied to named user accounts

    Shotgun's API uses session-based authentication tied to a named user account. There is no documented API key or service account model. When the user whose credentials are used for migration is deactivated or changes roles, the migration session is invalidated mid-transfer. We coordinate credential scoping during migration planning and recommend provisioning a dedicated integration account that will not be deprovisioned during the migration window. If a dedicated account is not available, we recommend scheduling migration runs in a single session before any account changes occur.

  • Version and review history has no migration path to Jira native objects

    Shotgun's Version chain with per-shot annotation and comparison tools is a core production workflow feature with no equivalent in standard Jira. Annotations and version comparisons (e.g., diff between v3 and v7 of a Shot) cannot be represented in Jira's data model. We reconstruct version chains as ordered comments on the parent Story, which preserves version metadata (number, artist, date, status) but loses the visual comparison and annotation layers. Studios with strict review and approval governance may need to retain Shotgun as a review companion tool or invest in a Jira-compatible review app from the Atlassian Marketplace.

  • Attachment blob pacing on large render files

    Shotgun's Python API has no built-in bandwidth limiting for attachment downloads. Large render outputs, video files, and published media linked to Shots and Assets can saturate studio WAN links during migration windows. We chunk Attachment downloads into staged batches and manage download pacing at the platform level to avoid impacting studio network performance. Studios should confirm their available bandwidth and target transfer window with FlitStack AI during scoping, and should flag any files exceeding Jira's attachment size limits (10 MB Free, 250 MB Standard/Premium) for external linking strategy.

Migration approach

Six steps for a successful Shotgun to Jira data migration

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

Context on both ends of the pair

Shotgun logo

Shotgun

Source

Strengths

  • Rich entity model purpose-built for animation, VFX, and game production pipelines.
  • Strong version and review workflow with per-shot annotation and comparison tools.
  • Customizable pipeline stages and entity schemas to match studio-specific terminology.
  • Integrations with Maya, Nuke, Houdini, and other DCC tools keep artist data canonical.
  • Per-project permission granularity controls visibility across large studio deployments.

Weaknesses

  • API rate limits are not publicly documented, causing migration scripts to fail without warning.
  • Authentication relies on individual user accounts rather than service tokens, breaking automated migrations when users leave.
  • Performance degrades on Projects with tens of thousands of Task or Shot records.
  • No bulk export or dedicated migration API endpoint means all data must be read record-by-record via find queries.
  • Custom field schemas vary between ShotGrid sites, requiring field-level mapping work for each migration.
Jira logo

Jira

Destination

Strengths

  • Deeply customizable workflows and status schemes with no hard limits on workflow complexity or number of custom statuses.
  • Strong agile ceremony support: sprint planning, backlog grooming, velocity tracking, and burndown charts for Scrum teams.
  • Industry-standard developer tool with native Git integration linking commits, pull requests, and deployments to issues.
  • Large Atlassian Marketplace with thousands of plugins extending time tracking, portfolio management, and reporting capabilities.
  • Free tier available for up to 10 users with unlimited issues, enabling evaluation before committing to a paid plan.

Weaknesses

  • Excessive configurability creates a steep learning curve; cross-team consistency is hard to maintain without strict governance.
  • Performance degrades with large backlogs, complex custom fields, and heavily nested issue hierarchies.
  • Reporting requires additional configuration or paid plugins; out-of-the-box analytics are limited for business users.
  • Jira lacks native sprint management, requiring Jira Software for true agile team features.
  • Teams outside engineering resist adoption due to UI complexity, leaving the all-in-one promise unfulfilled for cross-functional organizations.

Complexity grading

How hard is this migration?

Standard Project Management migration. 3 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Shotgun and Jira.

  • Object compatibility

    B

    3 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    Shotgun: Not publicly documented. Community reports confirm quota enforcement at the authorization endpoint with no self-service visibility into current usage..

  • Data volume sensitivity

    B

    Shotgun doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Shotgun to Jira migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Shotgun to Jira data migrations

Answers to the questions buyers ask most during Shotgun to Jira migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your Shotgun to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most migrations land between three and five weeks for studios under 10,000 Shots, 5,000 Assets, and 50,000 Tasks with a straightforward pipeline status model. Migrations with extensive version chains (over 20,000 Version records), large attachment volumes (500+ GB of render outputs), multi-site Shotgun instances requiring consolidation, or studio-specific custom field schemas that need per-field mapping work extend to eight to twelve weeks because of staged download pacing, version chain reconstruction, and schema reconciliation across sites.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Shotgun.
Land in Jira, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day