Back to Brand Asset Management

Integration and API Spec

The reference during the build: every tool connection, auth scope, field mapping, and error-handling rule.

4 pagesPDF · Technical
FS-DOC-05Technical

Integration and API Spec

Brand Asset Management Automation

[YourCompany.com] · Marketing Department · Prepared by FullSpec · [Today's Date]

This document is the authoritative technical reference for every external service connection used in the Brand Asset Management automation. It covers authentication methods, required OAuth scopes, webhook configuration, field mappings between tools, credential store layout, orchestration design, and failure handling for all integration points. The FullSpec team uses this document during build and refers to it throughout testing and go-live. No credentials or scope strings should be hard-coded into workflow steps; all values must live in the shared credential store documented in Section 04.

01Tool inventory

Tool
Role in automation
Auth method
Min plan required
Used by agents
Google Drive
Staging folder trigger; asset file source; archive destination; asset register (Google Sheets)
OAuth 2.0 (service account)
Google Workspace Business Starter ($6/user/month)
Agent 1, Agent 3
Brandfolder
Approved asset library; upload destination; permission and tagging target
API key (Bearer token)
Brandfolder Team ($79/month)
Agent 1, Agent 3
Asana
Review task creation; approval decision capture; rejection routing
OAuth 2.0 (personal access token supported)
Asana Premium ($10.99/user/month)
Agent 2
Slack
Approval request messages; 24-hour reminders; new asset notifications
OAuth 2.0 (bot token)
Slack Pro ($7.25/user/month)
Agent 2, Agent 3
Google Sheets (via Google Drive API)
Asset register updates: version, approval date, Brandfolder link
OAuth 2.0 (same service account as Drive)
Included in Google Workspace
Agent 3
Workflow automation platform (orchestration layer)
Hosts all agent workflows; manages credential store; executes polling and webhook handling
Internal (platform-managed)
Platform plan covering 3 active workflows and ~210 runs/month
All agents
Before you connect anything: create sandbox or test instances for Google Drive, Asana, Slack, and Brandfolder before supplying any production credentials. Validate every OAuth flow and API key response in the sandbox environment. Only after all connections return healthy status codes in test should production credentials be loaded into the credential store.

02Per-tool integration detail

Google Drive

Google Drive serves two roles: it is the inbound staging folder that triggers Agent 1, and it is the archive destination where Agent 3 moves superseded files. Google Sheets (accessed via the same Drive API service account) is written by Agent 3 to update the asset register.

Auth method
OAuth 2.0 using a dedicated service account (JSON key file). The service account must be granted 'Editor' access to the staging folder, archive folder, and the asset register Google Sheet. Do not use a personal user account.
Required scopes
https://www.googleapis.com/auth/drive, https://www.googleapis.com/auth/drive.file, https://www.googleapis.com/auth/drive.metadata.readonly, https://www.googleapis.com/auth/spreadsheets
Trigger / webhook setup
Google Drive does not support outbound webhooks natively at the folder level without the Push Notifications API. Use the automation platform's polling mechanism to call files.list on the staging folder every 2 minutes. Filter by createdTime greater than the last-seen timestamp stored in workflow state. Alternatively, configure a Drive Push Notification channel (Drive API v3 files.watch) targeting the orchestration layer's inbound webhook URL; the channel must be renewed every 7 days via a scheduled maintenance step.
Required configuration
DRIVE_STAGING_FOLDER_ID, DRIVE_ARCHIVE_FOLDER_ID, and SHEETS_REGISTER_ID must be stored in the credential store, not hard-coded. The staging folder must be a single dedicated folder; subfolders are not recursively monitored. The archive folder must exist prior to go-live.
Rate limits
Drive API: 1,000 requests/100 seconds per user; 10,000 requests/100 seconds per project. Sheets API: 300 write requests/minute per project. At ~40 assets/month (~1-2 per day), both limits are comfortably below threshold. No throttling logic required at current volume.
Constraints
The service account cannot access files in 'My Drive' of individual users; assets must be in a shared drive or a folder explicitly shared with the service account. Files larger than 5 GB cannot be processed via the standard Drive API export endpoints.
// Polling call
GET https://www.googleapis.com/drive/v3/files
  ?q='DRIVE_STAGING_FOLDER_ID' in parents and createdTime > '{{last_polled_at}}'
  &fields=files(id,name,mimeType,createdTime,owners,size)
  &orderBy=createdTime desc

// Archive move call (Agent 3)
PATCH https://www.googleapis.com/drive/v3/files/{{file_id}}
  ?addParents=DRIVE_ARCHIVE_FOLDER_ID
  &removeParents=DRIVE_STAGING_FOLDER_ID

// Sheets append call (Agent 3)
POST https://sheets.googleapis.com/v4/spreadsheets/{{SHEETS_REGISTER_ID}}/values/AssetRegister!A:G:append
  ?valueInputOption=USER_ENTERED
  body: { values: [[asset_name, asset_type, campaign, version, approved_at, brandfolder_url, drive_archive_id]] }
Brandfolder

Brandfolder is the approved asset library. Agent 1 queries it for duplicate detection. Agent 3 uploads the approved, tagged asset, sets permissions, and marks the prior version as superseded.

Auth method
API key passed as a Bearer token in the Authorization header. Generate the key from the Brandfolder account owner's profile. Store as BRANDFOLDER_API_KEY in the credential store.
Required scopes
Brandfolder uses key-based auth without granular OAuth scopes. The API key must belong to an account with 'Admin' role on the target organization so that it can create assets, update metadata, set section permissions, and modify asset status. Read-only keys are insufficient for Agent 3.
Webhook / trigger setup
Brandfolder is not a trigger source in this automation. No inbound webhook is required. All calls are outbound from the orchestration layer to the Brandfolder REST API.
Required configuration
BRANDFOLDER_ORG_KEY, BRANDFOLDER_COLLECTION_ID (the target approved-asset collection), and BRANDFOLDER_SECTION_IDS (a map of asset_type to section ID, e.g. logos, templates, photography) must be stored in the credential store. The collection hierarchy must be finalised before build; adding sections post-launch requires a workflow update.
Rate limits
Brandfolder REST API: 3,600 requests/hour per API key. At ~40 uploads/month, peak demand is well under 1% of this limit. No throttling logic required at current volume.
Constraints
File uploads to Brandfolder via API use a two-step process: first create the asset record (POST /assets), then attach the file binary via a signed upload URL. Both steps must succeed before the asset is considered live. If the file attachment step fails, the orphaned asset record must be deleted to avoid ghost entries.
// Duplicate search (Agent 1)
GET https://brandfolder.com/api/v4/collections/{{BRANDFOLDER_COLLECTION_ID}}/assets
  ?search={{asset_name_normalised}}&fields=id,name,cdn_url,status
  Authorization: Bearer {{BRANDFOLDER_API_KEY}}

// Create asset record (Agent 3)
POST https://brandfolder.com/api/v4/sections/{{section_id}}/assets
  body: { data: { attributes: { name, description, attachment_url } } }

// Mark prior version superseded (Agent 3)
PATCH https://brandfolder.com/api/v4/assets/{{prior_asset_id}}
  body: { data: { attributes: { status: 'expired' } } }
Asana

Asana hosts the brand approval workflow. Agent 2 creates a review task, assigns it to the brand lead, and polls for a completion event. Rejection routes the task back to the designer via a sub-task or a separate task in the designer's project.

Auth method
OAuth 2.0. Use a dedicated Asana service account (not a personal account) and generate a personal access token (PAT) for server-to-server integration. Store as ASANA_PAT in the credential store. OAuth 2.0 app registration is required if the platform needs token refresh; PAT is valid indefinitely until revoked.
Required scopes
default (full access to workspaces, projects, tasks, and events the service account can see). Asana PATs do not use granular scope strings; access is governed by the service account's workspace membership. The service account must be a member of the brand approval project.
Webhook / trigger setup
Register an Asana webhook on the brand approval project to receive task-completion and task-update events. Endpoint: POST https://app.asana.com/api/1.0/webhooks with target pointing to the orchestration layer's inbound URL. Asana sends an X-Hook-Signature header (HMAC-SHA256); the orchestration layer must validate this signature using ASANA_WEBHOOK_SECRET before processing any payload. The webhook must be re-registered if the orchestration layer URL changes.
Required configuration
ASANA_WORKSPACE_ID, ASANA_APPROVAL_PROJECT_ID, ASANA_BRAND_LEAD_USER_ID, ASANA_DESIGNER_USER_ID, and ASANA_WEBHOOK_SECRET must be stored in the credential store. Task due dates are calculated as now + 48 hours at creation time. The 24-hour reminder is a scheduled check: if the task remains incomplete 24 hours after creation, Agent 2 posts the Slack reminder.
Rate limits
Asana API: 1,500 requests/minute per OAuth app. At ~40 tasks/month, this limit will never be approached. No throttling required.
Constraints
Asana webhooks deliver events asynchronously and may occasionally deliver duplicates. The orchestration layer must deduplicate on task GID before acting. Webhook deliveries are retried by Asana for up to 24 hours if the target returns a non-2xx status.
// Create review task (Agent 2)
POST https://app.asana.com/api/1.0/tasks
  Authorization: Bearer {{ASANA_PAT}}
  body: {
    data: {
      name: 'Brand Approval: {{asset_name}} v{{version}}',
      projects: ['{{ASANA_APPROVAL_PROJECT_ID}}'],
      assignee: '{{ASANA_BRAND_LEAD_USER_ID}}',
      due_on: '{{now + 48h ISO date}}',
      notes: 'Asset type: {{asset_type}}\nCampaign: {{campaign}}\nDrive link: {{drive_file_url}}\nDuplicate flag: {{duplicate_flag}}'
    }
  }

// Webhook event payload (inbound, task completed)
POST {{orchestration_webhook_url}}
  X-Hook-Signature: sha256={{hmac_signature}}
  body: { events: [{ resource: { gid: '{{task_gid}}' }, action: 'changed', change: { field: 'completed', new_value: true } }] }
Integration and API SpecPage 1 of 4
FS-DOC-05Technical
Slack

Slack is used by Agent 2 to send the initial approval request and the 24-hour reminder to the brand lead, and by Agent 3 to post the new-asset notification to the brand-assets channel after a successful Brandfolder upload.

Auth method
OAuth 2.0 bot token. Register a Slack app in the target workspace, grant the required bot token scopes, install the app to the workspace, and store the bot token as SLACK_BOT_TOKEN in the credential store.
Required scopes
chat:write, chat:write.public, channels:read, users:read, users:read.email
Webhook / trigger setup
Slack is not a trigger source in this automation. All calls are outbound from the orchestration layer to the Slack Web API. If a future version requires interactive button responses (approve/reject directly in Slack), the app would need the Interactivity feature enabled with a Request URL pointing to the orchestration layer. This is not in scope for the current build.
Required configuration
SLACK_BOT_TOKEN, SLACK_BRAND_LEAD_USER_ID (for direct messages), and SLACK_BRAND_ASSETS_CHANNEL_ID (for public notifications) must be stored in the credential store. Message templates must use Block Kit JSON and must not be hard-coded into workflow steps; store them as reusable template variables.
Rate limits
Slack Web API: Tier 3 methods (chat.postMessage) allow 50 calls/minute. At ~40 approval requests/month plus reminders and notifications, peak usage is well under the limit. No throttling logic required at current volume.
Constraints
The bot must be invited to SLACK_BRAND_ASSETS_CHANNEL_ID before it can post there. Direct messages require the brand lead's Slack user ID, not their display name. Messages posted to a DM thread cannot be deleted programmatically without the chat:write scope on that DM.
// Approval request DM (Agent 2)
POST https://slack.com/api/chat.postMessage
  Authorization: Bearer {{SLACK_BOT_TOKEN}}
  body: {
    channel: '{{SLACK_BRAND_LEAD_USER_ID}}',
    text: 'Brand approval needed: {{asset_name}}',
    blocks: [
      { type: 'section', text: { type: 'mrkdwn', text: '*{{asset_name}}* ({{asset_type}}) is ready for review.\n<{{drive_file_url}}|Open file> | <{{asana_task_url}}|Asana task>' } }
    ]
  }

// New asset notification (Agent 3)
POST https://slack.com/api/chat.postMessage
  body: {
    channel: '{{SLACK_BRAND_ASSETS_CHANNEL_ID}}',
    text: 'New approved asset: {{asset_name}} v{{version}} is live in Brandfolder.',
    blocks: [
      { type: 'section', text: { type: 'mrkdwn', text: ':white_check_mark: *{{asset_name}}* v{{version}} — {{asset_type}} — <{{brandfolder_url}}|View in Brandfolder>' } }
    ]
  }

03Field mappings between tools

The following tables document every data handoff between tools. Field names are shown as exact identifiers used in API payloads and workflow variable references. All intermediate values must be stored in the workflow's execution context between steps and must not rely on re-fetching from the source tool.

Handoff A: Google Drive to Agent 1 (Asset Intake and Classification Agent)

Source tool
Source field
Destination tool / context
Destination field
Google Drive
`files[].id`
Workflow context
`drive_file_id`
Google Drive
`files[].name`
Workflow context
`raw_file_name`
Google Drive
`files[].mimeType`
Workflow context
`mime_type`
Google Drive
`files[].createdTime`
Workflow context
`uploaded_at`
Google Drive
`files[].owners[0].emailAddress`
Workflow context
`uploader_email`
Google Drive
`files[].size`
Workflow context
`file_size_bytes`

Handoff B: Agent 1 classification output to Agent 2 (Approval Workflow Agent) via Asana task

Source tool
Source field
Destination tool
Destination field
Workflow context (Agent 1 output)
`asset_type`
Asana task body
`data.notes` (inline label)
Workflow context (Agent 1 output)
`campaign`
Asana task body
`data.notes` (inline label)
Workflow context (Agent 1 output)
`version`
Asana task name suffix
`data.name`
Workflow context (Agent 1 output)
`duplicate_flag`
Asana task body
`data.notes` (inline label)
Workflow context (Agent 1 output)
`normalised_asset_name`
Brandfolder search query
`search` param
Workflow context
`drive_file_id`
Asana task body
`data.notes` (Drive link constructed)

Handoff C: Agent 2 approval decision to Agent 3 (Library Update and Archive Agent)

Source tool
Source field
Destination tool
Destination field
Asana webhook payload
`events[0].resource.gid`
Workflow context
`asana_task_gid`
Asana task fetch (GET /tasks/gid)
`data.completed`
Workflow context
`approval_decision`
Asana task fetch
`data.notes`
Workflow context
`rejection_notes`
Asana task fetch
`data.completed_at`
Workflow context
`approved_at`
Workflow context (carried from Agent 1)
`drive_file_id`
Brandfolder upload
`attachment_url` (Drive export link)
Workflow context (carried from Agent 1)
`asset_type`
Brandfolder section lookup
`section_id` (via BRANDFOLDER_SECTION_IDS map)
Workflow context (carried from Agent 1)
`normalised_asset_name`
Brandfolder asset record
`data.attributes.name`
Workflow context (carried from Agent 1)
`version`
Brandfolder asset record
`data.attributes.description` (version label)

Handoff D: Agent 3 output to Google Sheets asset register

Source tool
Source field
Destination tool
Destination field
Workflow context
`normalised_asset_name`
Google Sheets row
Column A: `asset_name`
Workflow context
`asset_type`
Google Sheets row
Column B: `asset_type`
Workflow context
`campaign`
Google Sheets row
Column C: `campaign`
Workflow context
`version`
Google Sheets row
Column D: `version`
Workflow context
`approved_at`
Google Sheets row
Column E: `approved_at`
Brandfolder API response
`data.attributes.cdn_url`
Google Sheets row
Column F: `brandfolder_url`
Workflow context
`drive_file_id`
Google Sheets row
Column G: `drive_archive_id`
Integration and API SpecPage 2 of 4
FS-DOC-05Technical

04Build stack and orchestration

Orchestration layout
Three discrete workflows, one per agent. Each workflow is independently deployable and testable. Workflows share a single credential store; no credentials are duplicated across workflows. Shared workflow state (drive_file_id, asset_type, version, campaign, duplicate_flag, normalised_asset_name) is passed between Agent 1 and Agent 2 via a persistent workflow data store keyed on drive_file_id. Agent 2 writes the approval decision and asana_task_gid back to the same store so Agent 3 can retrieve full context without re-calling upstream tools.
Agent 1 trigger mechanism
Poll. The orchestration layer calls the Google Drive files.list endpoint every 2 minutes, filtering for files created in the staging folder since the last successful poll timestamp. The last-seen timestamp is stored in workflow state and updated after each successful run. If a Drive Push Notification channel is configured, the poll interval can be increased to 15 minutes as a fallback check. Deduplication is enforced by storing processed drive_file_id values in a short-lived set (TTL 24 hours).
Agent 2 trigger mechanism
Webhook (Asana). Agent 2 is triggered by an inbound Asana webhook event on the brand approval project. The orchestration layer validates the X-Hook-Signature HMAC-SHA256 header using ASANA_WEBHOOK_SECRET before processing. On signature validation failure the platform returns HTTP 401 and logs the event. The 24-hour reminder sub-step uses an internal scheduled delay node rather than a second external webhook.
Agent 3 trigger mechanism
Webhook (internal, chained). Agent 2 emits an internal trigger to Agent 3's workflow when the Asana task is marked completed and the approval_decision is confirmed as approved. This internal trigger carries the full shared state payload. Agent 3 does not poll any external source; it acts entirely on the data provided by Agent 2.
Credential store location
Platform-native secrets manager or encrypted environment variable store. All keys listed in the code block below must be stored there. No credential may appear in a workflow step's configuration field as plain text.
Workflow naming convention
bam-agent-01-intake-classification, bam-agent-02-approval-workflow, bam-agent-03-library-archive. The prefix 'bam-' scopes all workflows to this process for easy identification and bulk management.
Execution environment
All workflows run in the cloud-hosted orchestration environment. No local or on-premise runner is required. Estimated monthly execution volume: ~210 runs/month across all three workflows, well within any standard automation platform tier.
Credential store: all keys required before any workflow is activated. Replace placeholder values with production credentials only after sandbox testing is complete.
// Credential store contents
// All values are encrypted at rest. Reference by key name only in workflow steps.

// Google Drive / Sheets (service account)
GOOGLE_SERVICE_ACCOUNT_JSON       = { ... full service account JSON key ... }
DRIVE_STAGING_FOLDER_ID           = '1aBcDeFgHiJkLmNoPqRsTuVwXyZ_staging'
DRIVE_ARCHIVE_FOLDER_ID           = '2bCdEfGhIjKlMnOpQrStUvWxYz_archive'
SHEETS_REGISTER_ID                = '3cDeFgHiJkLmNoPqRsTuVwXyZa_register'

// Brandfolder
BRANDFOLDER_API_KEY               = 'bf_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx'
BRANDFOLDER_ORG_KEY               = 'org_xxxxxxxxxxxxxxxx'
BRANDFOLDER_COLLECTION_ID         = 'col_xxxxxxxxxxxxxxxx'
BRANDFOLDER_SECTION_IDS           = {
  'logo':        'sec_aaaaaaaaaaaaaaaa',
  'template':    'sec_bbbbbbbbbbbbbbbb',
  'photography': 'sec_cccccccccccccccc',
  'guideline':   'sec_dddddddddddddddd',
  'other':       'sec_eeeeeeeeeeeeeeee'
}

// Asana
ASANA_PAT                         = 'ey...personal_access_token...'
ASANA_WORKSPACE_ID                = '123456789012345'
ASANA_APPROVAL_PROJECT_ID         = '987654321098765'
ASANA_BRAND_LEAD_USER_ID          = '111122223333444'   // James Okoro
ASANA_DESIGNER_USER_ID            = '555566667777888'
ASANA_WEBHOOK_SECRET              = 'wh_sec_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'

// Slack
SLACK_BOT_TOKEN                   = 'xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxx'
SLACK_BRAND_LEAD_USER_ID          = 'U0XXXXXXXXX'   // James Okoro Slack ID
SLACK_BRAND_ASSETS_CHANNEL_ID     = 'C0XXXXXXXXX'   // #brand-assets channel
BRANDFOLDER_SECTION_IDS is a structured map, not a flat string. Confirm with the Brandfolder admin that all section IDs exist and are active before storing them. A missing section ID will cause Agent 3 to fail at the upload step with a 404 response from Brandfolder.
Integration and API SpecPage 3 of 4
FS-DOC-05Technical

05Error handling and retry logic

Every integration point has a defined failure behaviour. Unhandled exceptions must never fail silently. Where a step cannot complete after exhausting retries, the workflow must write a structured error record to the operations log and send an alert to support@gofullspec.com and the designated process owner. The table below covers all failure scenarios across all three agents.

Integration
Scenario
Required behaviour
Google Drive (Agent 1 poll)
Drive API returns 5xx or timeout
Retry 3 times with exponential backoff (30 s, 60 s, 120 s). If all retries fail, skip this poll cycle and resume at the next scheduled interval. Log the failed poll with timestamp. Do not advance the last-seen timestamp so the file is picked up on the next successful poll.
Google Drive (Agent 1 poll)
Staging folder ID not found (404)
Halt the workflow immediately. Write a CRITICAL error to the operations log. Alert the process owner and support@gofullspec.com. Do not retry automatically; this requires a configuration fix (DRIVE_STAGING_FOLDER_ID is wrong or the folder was deleted).
Brandfolder (Agent 1 duplicate search)
Brandfolder API returns 401 Unauthorized
Halt immediately. Do not proceed to task creation. Alert support@gofullspec.com with the event payload. The BRANDFOLDER_API_KEY has likely expired or been revoked. Manual credential rotation required before the workflow can resume.
Brandfolder (Agent 1 duplicate search)
Brandfolder API returns 5xx
Retry 3 times with exponential backoff (15 s, 30 s, 60 s). If all retries fail, set duplicate_flag to 'UNKNOWN' and continue the workflow. Include the UNKNOWN flag in the Asana task notes so the brand lead is aware the duplicate check could not be confirmed.
Asana (Agent 2 task creation)
Asana API returns 5xx or connection timeout
Retry 3 times with exponential backoff (30 s, 90 s, 180 s). If all retries fail, send a direct Slack DM to SLACK_BRAND_LEAD_USER_ID with the full asset details and Drive link as a manual fallback, and log the Asana failure. Do not drop the asset from the queue.
Asana (Agent 2 webhook inbound)
Webhook signature validation fails
Return HTTP 401 to Asana immediately. Do not process the payload. Log the event with the raw signature and timestamp. If more than 3 signature failures occur within 1 hour, alert support@gofullspec.com as this may indicate a secret rotation is needed or a replay attack.
Asana (Agent 2 24-hour reminder check)
Task GID no longer exists when reminder fires
Log the missing task GID with the original drive_file_id. Do not send the reminder. Alert the process owner so they can confirm whether the task was manually deleted or completed without triggering the webhook.
Slack (Agent 2 approval DM)
Slack API returns 'channel_not_found' or 'user_not_found'
Log the error with the target user ID. Send a fallback email to the brand lead using their email address retrieved from ASANA_BRAND_LEAD_USER_ID profile. Alert support@gofullspec.com to update SLACK_BRAND_LEAD_USER_ID in the credential store.
Brandfolder (Agent 3 asset upload)
Asset record created but file attachment step fails (upload URL expired or network error)
Immediately DELETE the orphaned asset record from Brandfolder using the asset ID returned in the creation response. Retry the full two-step upload sequence up to 2 more times with a 60-second delay between attempts. If all retries fail, log a CRITICAL error, alert support@gofullspec.com, and notify the process owner that the asset requires manual upload.
Google Drive (Agent 3 archive move)
Archive folder not found (404) or permission denied (403)
Do not delete the file from the staging folder. Log the failure with drive_file_id and the HTTP status. Alert the process owner. The Brandfolder upload may have already succeeded; the asset is live but the archive step is incomplete. Manual archive is required. Do not mark the workflow run as successful.
Google Sheets (Agent 3 register update)
Sheets API returns 5xx or quota exceeded (429)
Retry up to 3 times with backoff (30 s, 60 s, 120 s). If all retries fail, write the intended row data to the operations log as a structured JSON record so it can be manually added to the register. The Slack notification to the brand-assets channel must still fire regardless of whether the Sheets update succeeded.
Slack (Agent 3 new-asset notification)
Slack API returns 5xx or rate limit (429)
Retry once after 60 seconds. If the retry also fails, log the failure and alert support@gofullspec.com. Do not block the workflow from completing; the Brandfolder upload and archive steps are the critical path. The Slack notification is advisory and can be sent manually if the automated attempt fails.
Unhandled exceptions must never fail silently. Any exception not explicitly covered by the table above must be caught by a global error handler in the orchestration layer, written to the operations log with the full execution context (workflow name, run ID, step name, timestamp, raw error), and surfaced as an alert to support@gofullspec.com. A silent failure that allows an asset to bypass the approval step or remain un-archived is a business risk, not just a technical issue.
Integration and API SpecPage 4 of 4

More documents for this process

Every document generated for Brand Asset Management.

Launch Plan
Operations · Owner
View
ROI and Business Case
Finance · Owner
View
Process Runbook / SOP
Operations · Owner
View
Developer Handover Pack
Technical · Developer
View
Test and QA Plan
Quality · Developer
View