Project Management migration

Migrate from Shotgun to Asana

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

Shotgun logo

Shotgun

Source

Asana

Destination

Asana logo

Compatibility

79%

11 of 14

objects map 1:1 between Shotgun and Asana.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Shotgun to Asana is a schema translation, not a direct record copy. Shotgun organizes production around Shots, Assets, Sequences, and Versions with pipeline stages tied to entity-specific workflows; Asana organizes work around Tasks, Projects, Sections, and custom fields with no native equivalent for production entities. We map Shotgun Projects to Asana Teams or Projects, map Shots and Assets to Tasks with a production-kind custom field, preserve Version chains as ordered attachment sets, and rebuild pipeline stage workflows as custom single-select fields and Project Sections. Attachment blobs are staged in chunks against Shotgun's undocumented rate limits and reuploaded with Asana's 100 MB per-file ceiling flagged for review. Workflows, automations, and pipeline triggers do not migrate; we deliver a written inventory of every automation requiring rebuild in Asana Rules.

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

Asana logo

Asana

What's pulling them in

  • Organizations with distributed teams cite Asana's multiple project views (List, Board, Calendar, Timeline) as the primary reason for adoption, allowing each team member to work in their preferred interface without changing the underlying data.
  • The platform's 100+ native integrations with tools like Slack, Google Drive, Salesforce, and Microsoft Teams reduce context-switching and keep work synchronized across the stack.
  • Small teams and non-profits value the free plan's generous limits: unlimited projects and tasks for up to 15 team members with basic views, enabling teams to validate fit before committing to a paid tier.
  • Marketing and creative teams specifically praise Asana's visual project organization, reporting dashboards, and timeline views for managing cross-functional campaign workflows.
  • Project managers report that Asana's dependency management and workload views help surface bottlenecks before they derail deadlines.

Object mapping

How Shotgun objects map to Asana

Each row shows how a Shotgun object lands in Asana, 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

Asana

Project or Team

1:1
Fully supported

Shotgun Projects map to Asana Projects as the primary container. For studios with multiple distinct production groups, we map each Shotgun Project to an Asana Project within a Team. Project-level metadata including status, description, and start and due dates migrate as Project fields. The Asana Team structure is established first as the parent container so that Projects are created inside the correct Team scope.

Shotgun

Sequence

maps to

Asana

Project Section or Sub-Project

1:1
Fully supported

Shotgun Sequences group Shots into editorial acts or sequences and carry sequence-level metadata. We map Sequences to Asana Project Sections within the same Project, preserving the sequence-to-shot relationship as Section membership. If the studio uses Sequences as independent planning units, we map them to Sub-Projects within the parent Project to maintain editorial hierarchy.

Shotgun

Shot

maps to

Asana

Task

1:1
Fully supported

Shotgun Shots are the core production entity containing cut order, status, and assigned Tasks. We map Shots to Asana Tasks within the relevant Project or Section, preserving shot code as the Task name prefix (e.g., SEQ001_010) and shot description as the Task description field. Shot status maps to a custom single-select field sg_shot_status__c with values derived from the source pipeline stage list. Cut order is preserved as a custom number field sg_cut_order__c used for sorting.

Shotgun

Asset

maps to

Asana

Task

1:1
Fully supported

Shotgun Assets (characters, props, environments, and other reusable production elements) map to Asana Tasks with a custom field sg_asset_type__c indicating the asset kind (character, prop, environment, vehicle, etc.). Asset status migrates to a custom single-select field sg_asset_status__c. The Asset-to-Shot link (which Shots reference which Assets) is preserved as a custom multi-select field sg_linked_shots__c or as a Tag on the Asset Task.

Shotgun

Task

maps to

Asana

Subtask

1:1
Fully supported

Shotgun Tasks are assigned to Shots or Assets and contain pipeline stage, status, assignee, and due date. We map these to Asana Subtasks nested under the parent Shot or Asset Task, preserving Task status in a custom field sg_task_status__c, assignee as the subtask owner, and the pipeline stage as a custom field sg_pipeline_stage__c. Task priority from Shotgun maps to Asana Task Priority.

Shotgun

Version

maps to

Asana

Attachment or Comment Thread

lossy
Fully supported

Shotgun Versions are linked to Shots or Assets and represent review iterations. Asana has no native version-control equivalent, so we reconstruct the version chain as an ordered set of Task Attachments, with the version number and iteration notes preserved as a Comment on each version attachment. The most current Version is flagged with a custom field sg_current_version__c. Studios using Frame.io or Review 365 for review workflows may prefer to migrate Version metadata as task notes pointing to the external review platform.

Shotgun

Note

maps to

Asana

Comment

1:1
Fully supported

Shotgun Notes attach to any entity and support threaded Replies. We map Notes to Asana Comments on the corresponding Task. Reply depth is preserved as a comment threading indicator. Shot or Asset linkage is preserved via the parent Task reference. Note author from Shotgun maps to the Comment author field; note creation timestamp migrates as the Comment timestamp.

Shotgun

Attachment

maps to

Asana

Attachment

lossy
Fully supported

Shotgun Attachments include uploaded files, render outputs, and published media linked to Shots, Assets, or Versions. We use Shotgun's download_attachment and get_attachment_download_url endpoints to extract files, then upload to Asana via the attachments endpoint. We flag any file exceeding 100 MB for manual handling because Asana's API and UI both reject attachments above that size. Files are staged in batches with download pacing to stay within Shotgun's undocumented rate limits. Attachment metadata (filename, upload date, linked entity) is preserved in a FlitStack AI manifest for reconciliation.

Shotgun

Thumbnail

maps to

Asana

Task Attachment

1:1
Fully supported

Thumbnails are entity-level images for Shots, Assets, Versions, and Tasks. We extract them via upload_humbnail or download_attachment and re-associate them as Task Attachments in Asana, noting that Asana does not display thumbnails in list or board views the way Shotgun does. Studios using Asana primarily as a coordination layer rather than a review platform typically accept this trade-off. If visual reference is critical, we can attach the thumbnail as a pinned image to the Task description.

Shotgun

Custom Field

maps to

Asana

Custom Field

1:1
Fully supported

Shotgun custom fields vary widely between sites in type, display name, and list values. We perform field-level mapping during scoping, matching each Shotgun custom field type to the closest Asana custom field type (enum for list values, text for freeform, number for numeric, date for date fields). Custom field schemas are created in the destination Asana Project before data import, and field values migrate as typed values against the destination field GID. Custom fields that have no Asana equivalent (e.g., Shotgun entity reference fields pointing to other Shots) are flagged for review.

Shotgun

Pipeline Status

maps to

Asana

Section or Custom Single-Select Field

lossy
Fully supported

Shotgun pipeline statuses are customizable per entity type and vary widely between studios. We map the source site's pipeline stage workflow to either Asana Project Sections (for sequential editorial stages like Assembly, VFX, Composite) or a custom single-select field sg_pipeline_stage__c on Tasks (for parallel workflow stages). We flag any statuses that reference pipeline logic beyond simple ordering, such as automated approval gates, and document them in the automation inventory for rebuild in Asana Rules.

Shotgun

Tag / Label

maps to

Asana

Tag

1:1
Fully supported

Shotgun Tags are freeform labels applied to any entity. We preserve tag assignments as Asana Tags, mapping the Shotgun tag name directly to the Asana Tag name. Tag color is not carried over from Shotgun because Asana manages tag color internally. If tags represent classification categories (e.g., render priority, review status), we document the tag taxonomy for potential migration to custom single-select fields for stronger filtering in Asana.

Shotgun

User

maps to

Asana

User

1:1
Fully supported

Shotgun Users are persons with roles and permissions. We migrate the user record including name and contact email, but role and permission sets are destination-specific. User-to-Task assignment migrates by resolving the Shotgun user to an Asana User by email match. Any Shotgun user without a matching Asana User is placed in a reconciliation queue for the customer's admin to provision before Task import resumes. Admin and supervisor roles require manual reassignment in Asana after migration.

Shotgun

Work Schedule

maps to

Asana

Working Days (Asana Calendar)

1:1
Fully supported

Shotgun maintains work day rules via work_schedule_read and work_schedule_update. We extract the schedule configuration and attempt to apply it to the Asana Workspace's calendar working days settings, noting that Shotgun work schedules often encode studio-specific holidays and production blackouts that must be manually re-entered in Asana.

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

Asana logo

Asana gotchas

High

Automation rules have no export representation

High

API rate limits cap bulk migration throughput

Medium

Portfolios are view-only objects that do not hold data

Medium

Custom field enum options cannot be updated via API

Low

Subtasks do not appear in project views by default

Pair-specific challenges

  • No native equivalent for Shots, Assets, Sequences, or Versions

    Asana has no built-in entity types for production pipeline objects. Shots, Assets, Sequences, and Versions have no Asana native equivalent, so we translate them to Tasks, Projects, Sections, and attachment sets. This translation preserves the record and its metadata but loses the Shotgun-specific entity relationship model. Studios that rely on Shotgun's version comparison tool, per-shot annotation, or pipeline-triggered automations need to plan for those capabilities to be rebuilt or replaced by third-party review tools (Frame.io, Review 365) after migration. The version chain in particular requires a documented rebuild strategy because Asana does not support version iteration as a native concept.

  • Shotgun undocumented API rate limits require conservative batching

    Shotgun's authorization and data endpoints are subject to rate limits that are not published in the developer documentation. Community posts confirm that quota errors occur and that there is no self-service dashboard to monitor current usage. When we run a large migration against Shotgun, we batch requests and implement exponential backoff to avoid triggering these limits. We plan conservatively rather than aggressively, which affects migration timeline estimates for Projects with high record counts. Studios with multiple concurrent Projects may need to sequence Project migration rather than running them in parallel.

  • Asana attachment ceiling of 100 MB blocks large file transfers

    Asana's API and web UI both reject attachments exceeding 100 MB. Shotgun production environments frequently contain render outputs, texture archives, and published media well above this threshold. We flag every attachment exceeding 100 MB during the Shotgun inventory phase, report the total size and count of oversized files, and exclude them from the standard migration scope. Oversized files require a separate handling plan: either manual download and re-upload by the studio's pipeline team, or migration to a DAM platform (Shotgrid's built-in pipeline publish, Frame.io, or a dedicated DAM) with a reference link stored in the Asana Task.

  • API authentication tied to individual user accounts breaks mid-migration

    Shotgun's API authentication is session-based and 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 token is invalidated and the migration halts. We coordinate credential scoping during migration scoping, use a dedicated integration account that will not be deprovisioned during the migration window, and maintain a credential handoff checklist for long-running migrations. This is a known Shotgun platform limitation that affects any automated pipeline running against the Shotgun REST or Shotgun API.

  • Automation rebuild is out of scope and requires a written inventory

    Shotgun pipeline triggers, webhook automations, and review-iteration event hooks have no direct Asana equivalent. Asana Rules provide trigger-action automation but use a different event model. We do not migrate automations as code. We deliver a written inventory of every active Shotgun pipeline trigger and webhook, with its trigger event, conditions, and actions described in enough detail for the studio's project manager or pipeline TD to rebuild in Asana Rules or a third-party automation tool. The inventory is delivered before production migration begins so that the studio can prioritize which automations to rebuild first.

Migration approach

Six steps for a successful Shotgun to Asana data migration

  1. Discovery and migration scoping

    We audit the source Shotgun site across Projects, entity counts (Shots, Assets, Sequences, Tasks, Versions, Notes), custom field schemas, pipeline status configurations, tag taxonomy, and attachment inventory including file size distribution. We identify oversized attachments (above 100 MB) during this phase and flag them for manual handling. We pair this with an Asana workspace audit to identify existing Teams, Projects, and custom fields that may conflict with the incoming migration. The discovery output is a written migration scope, object mapping specification, and an oversized-file report.

  2. Schema setup and pipeline status design

    We design the destination schema in Asana. This includes creating the Team and Project structure, defining custom fields for sg_shot_status__c, sg_asset_status__c, sg_pipeline_stage__c, sg_cut_order__c, sg_asset_type__c, and any entity-specific custom fields carried from Shotgun. Pipeline statuses from Shotgun are mapped to either Project Sections or custom single-select fields based on whether the pipeline stages represent sequential editorial phases or parallel workflow assignments. Custom fields are deployed to the target Asana Projects before any data import to ensure field GIDs are available during record mapping.

  3. Credential provisioning and download pacing design

    We provision a dedicated Shotgun integration account that will remain active throughout the migration window. We configure the Shotgun Python API client with conservative request pacing and exponential backoff to work within the undocumented rate limits. We design the download batch schedule for Attachments and Thumbnails to run during off-peak studio hours to avoid saturating the studio WAN link. This phase produces a migration runbook with credential details, pacing parameters, and batch schedules reviewed by the studio's pipeline team.

  4. Sandbox migration and reconciliation

    We run a full migration into a test Asana Workspace using a representative subset of production data. The studio's production coordinator and pipeline lead reconcile record counts (Projects in, Sequences in, Shots in, Assets in, Tasks in, Notes in), spot-check 25-50 random Shot and Asset records against the Shotgun source, verify pipeline stage mapping in Sections and custom fields, and validate attachment presence. Mapping corrections are applied here before production migration begins. This step also validates that oversized attachments are correctly identified and documented for manual handling.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Shotgun Users (reconciled to Asana Users by email), Projects (to Asana Teams and Projects), Sequences (to Project Sections), Shots and Assets (to Tasks with sg_shot_status__c and sg_asset_type__c custom fields), Tasks (to Subtasks), Notes (to Comments), Versions (to Attachment sets and Comments), Attachments (in sized batches, excluding files above 100 MB), Thumbnails (as pinned Task Attachments), and Custom Field values (against the pre-deployed field GIDs). Each phase emits a row-count reconciliation report before the next phase begins. Credential validity is checked before each phase run.

  6. Cutover, validation, and automation inventory delivery

    We freeze Shotgun writes during cutover, run a final delta migration of any records modified during the migration window, then hand over Asana as the system of record for the migrated scope. We deliver the automation inventory document listing every Shotgun pipeline trigger and webhook with its trigger conditions, actions, and recommended Asana Rules equivalent. We support a one-week hypercare window where we resolve any reconciliation issues raised by the studio's team. We do not rebuild Shotgun automations or pipeline triggers as Asana Rules inside the migration scope; that work is handled by the studio's pipeline TD or a separate automation engagement.

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.
Asana logo

Asana

Destination

Strengths

  • Unlimited projects and tasks on the free plan for teams up to 15 members.
  • 100+ native integrations including Salesforce, Slack, Google Drive, and Microsoft Teams.
  • Four distinct project views (List, Board, Calendar, Timeline) in a single interface.
  • Dependency management with start/end dates and predecessor links for critical path tracking.
  • Portfolio dashboards for executives to track cross-project status and workload.

Weaknesses

  • Per-seat pricing scales expensively: Advanced tier costs nearly double Starter for a 50-seat team.
  • API does not expose all UI-accessible data; some fields require screen-scraping for full fidelity.
  • Automation rule limits on lower tiers are restrictive, causing power users to upgrade or leave.
  • No native document/wiki capability forces teams to use external tools for knowledge management.
  • Rate limits (150 req/min on free, 1,500 req/min on paid) constrain bulk migration throughput.

Complexity grading

How hard is this migration?

Standard Project Management migration. 2 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 Asana.

  • Object compatibility

    B

    2 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 Asana 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 Asana data migrations

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

Can't find your answer?

Walk through your Shotgun to Asana 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 with up to 15,000 total Shot, Asset, and Task records and a single pipeline stage configuration. Migrations with large Version chains, high-volume Attachment blobs requiring chunking and manual size triage against Asana's 100 MB ceiling, or multiple independent Projects with separate pipeline stage sets move to eight to fourteen weeks because of download pacing against Shotgun's undocumented API rate limits, schema mapping work for production entity translation, and the pipeline status rebuild documentation scope.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Shotgun.
Land in Asana, 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