Using ShotGrid Custom Entities to Track Proprietary R&D Assets

The problem: non‑standard data in a production pipeline

Studios regularly generate information that does not fit ShotGrid’s built‑in Asset, Shot, or Task types—research prototypes, patent sketches, internal notes, or experimental parameters. Teams often resort to shared spreadsheets, wiki pages, or ad‑hoc databases, which creates silos, version‑control headaches, and permission gaps.

Thesis: a custom entity gives you a queryable, permission‑aware object

ShotGrid’s Custom Entities feature (available on Enterprise tiers) lets you define new object types that inherit the platform’s core capabilities: field‑level permissions, revision history, API access, and UI integration. By modeling your R&D data as a custom entity, you keep everything inside ShotGrid without maintaining a separate system.

Section 1: Defining a ResearchNote custom entity

1. Log in as an administrator and go to Admin → Settings → Custom Entities.
2. Click Create Custom Entity and name it ResearchNote.
3. Add the following fields:
   • Title – Multi‑line Text (required)
   • Date – Date
   • Linked Asset – Multi‑Entity Reference (target type: Asset)
   • Tags – Choice List (pre‑populate with values like experiment, patent, idea)
4. Save the entity. ShotGrid will automatically generate the corresponding API schema and add the entity to the left‑hand navigation under Data.

At this point you can create ResearchNote records directly from the UI, attach them to assets, and see them in asset detail panels.

Section 2: Querying ResearchNotes with the ShotGrid API

The following Python snippet demonstrates how to retrieve all notes linked to a specific asset. Replace the placeholders with your instance’s values.

import shotgrid_api

# --- Configuration ---
host = "https://YOUR_SHOTGRID_HOST.shotgrid.autodesk.com"
script_name = "YOUR_SCRIPT_NAME"
api_key = "YOUR_API_KEY"

# Initialize connection
sg = shotgrid_api.ShotGrid(host, script_name=script_name, api_key=api_key)

# Asset you want to query – replace with the actual asset ID
target_asset_id = 12345

# Build filters: find ResearchNotes where Linked Asset contains the asset
filters = [
    ["linked_asset", "is", {"type": "Asset", "id": target_asset_id}]
]

# Fields to return
fields = ["id", "title", "date", "tags"]

notes = sg.find("ResearchNote", filters, fields)

for note in notes:
    print(f"Note {note['id']}: {note['title']} ({note['date']}) – Tags: {note['tags']}")

Run the script from a workstation with network access to your ShotGrid server. The output lists each note’s ID, title, date, and tag list, showing that the custom entity is fully queryable just like built‑in types.

Section 3: Trade‑offs and governance considerations

• Schema complexity – Each new field adds to the overall data model. Changes (e.g., renaming a field or altering its type) require admin approval and can break existing API calls or UI views.
• Tier limitation – Custom Entities are only available on ShotGrid Enterprise plans; verify your subscription before investing time.
• Migration safety – ShotGrid does not provide automatic backward‑compatible migrations. Treat schema changes as version‑controlled scripts and test them in a sandbox instance first.
• Permission inheritance – By default, a new entity inherits the role‑based permissions of the parent project. To hide it from certain users, create a role without read access to the entity and assign it accordingly.

Actionable closing: start small, iterate, and validate

1. Enable Custom Entities in Admin → Settings → Custom Entities.
2. Create a minimal prototype (e.g., just Title and Date) and confirm it appears in the UI.
3. Run the API snippet above against a test asset and verify the returned data.
4. Test permission inheritance: assign a role lacking read access, log in as a user with that role, and confirm the entity is hidden from lists and searches.
5. Gather feedback from artists and researchers, then iterate on the field set (add Tags, Linked Asset, etc.) while documenting each change.

By following these steps you turn ad‑hoc research notes into a first‑class, queryable object inside ShotGrid, gaining version control, permissions, and API access without leaving the platform.