Workflow: Scaling Global Image Deliverables

A practical, automation-first workflow to scale global image deliverables — from request to publish, tailored for commissioners and VPs.

Hook: When a global campaign can’t wait for manual file wrangling

Commissioners and VPs in charge of global promotions — think streaming launches and territory rollouts like those at major platforms — have three priorities: speed, consistency, and legal safety. Yet teams still lose days to wrong sizes, missing metadata, confusing file formats and slow approval loops. This guide gives a practical, step-by-step workflow to scale image deliverables across territories while keeping quality, speed and compliance high.

Quick overview — The 8-stage workflow (inverted pyramid)

Most important first: enforce clear specs at request time, automate ingestion + QC, run approvals in parallel with automated transformations, and publish using CDN-format negotiation. Here’s the distilled pipeline you'll use and tune:

Commission & asset request (standardized briefs)
Pre-production: style guide, naming, rights matrix
Production & ingest: watch folders and checksum-ing
Automated QC & optimization: format conversion, size budgets
Review & approval pipeline: annotation-first, parallel checks
Localization & territory variants: metadata-driven variants
Publish to CDN/CMS: on-the-fly variants & cache strategy
Monitoring, analytics & post-mortem

Why this matters in 2026 — trends that change the rules

Recent developments (late 2025 & early 2026) make automation non-negotiable:

CDN-side image negotiation (Accept header / AVIF/WebP): Most major CDNs now support on-the-fly conversion and responsive sizing. That reduces the need to store dozens of precooked files.
AI-assisted QC and variant generation: Visual LLMs and image-aware models can flag composition problems, suggest crops per territory and generate localized text overlays.
Stricter metadata & privacy expectations: IPTC/XMP handling and redaction requirements need to be baked into ingest workflows to avoid GDPR mistakes.
Rising format diversity: AVIF and high-quality WebP are widely supported; older JPEG-only assumptions cost bandwidth and engagement.

Step 1 — Commission & asset request: make the brief the contract

Successful campaigns begin with a request that behaves like a contract. Build a simple web form or a templated Google/Notion doc and require the following fields:

Use case (hero, thumbnail, billboard)
Primary territory and list of localized territories
Resolution & aspect targets (e.g., 3:2 hero, 1:1 thumbnail)
File format & pixel density requirement (source: TIFF/RAW, delivery: JPG/PNG + AVIF)
Rights & license window (start/end dates, exclusivity, territory)
Accessibility needs (alt text, image description)
Acceptance criteria — measurable (max file size, LCP budget, color profile)

Require the requester to pick one of three acceptance templates: Express (fast, fewer variants), Standard (balanced), or Full Localize (per-territory custom art).

Request template (example)

{
  "campaign":"STREAM_FALL24",
  "useCase":"hero",
  "territories":["UK","FR","DE"],
  "sourceRequirement":"RAW/16-bit TIFF",
  "deliveryFormats":["AVIF","JPEG"],
  "rights":{"start":"2026-02-01","end":"2027-02-01","territory":"EMEA"},
  "acceptance":{"maxFileKb":250,"minWidthPx":2000}
}

Step 2 — Pre-production & style guide: reduce creative variance

Create a short, shareable style guide for each campaign. Include:

Master color swatches and corporate safe zones
Permitted logo sizes and placement grids
Exact text overlays and font files for localization teams
Naming and slug conventions (see below)

Naming convention (sample)

Use a consistent slug: CAMPAIGN_usecase_territory_variant_v{version}.{ext}

Example: STREAMF24_hero_UK_final_v02.avif

Step 3 — Production & ingest: automate the handoff

Eliminate manual downloads. Require delivery to a controlled ingest endpoint (SFTP, cloud watch folder, or direct upload to DAM). Key automation steps:

Automated checksum and virus scan on upload
Immediate XMP/IPTC extraction and validation against the request manifest
Generate a low-resolution proxy for review tools
Assign a task to a QC engineer if mandatory fields are missing

Ingest automation: example with a watch folder + shell

# inotify-based watcher (Linux)
while inotifywait -e close_write /ingest; do
  file=$(ls -t /ingest | head -n1)
  sha256sum /ingest/$file > /ingest/checksums/$file.sha256
  cp /ingest/$file /processing/
  # trigger microservice or webhook here
done

Step 4 — Automated QC & optimization: rules, not opinions

This is where you win back time. Run automated checks first, then route to human review only when rules fail. Typical checks:

Dimensions and DPI
Color profile (sRGB requirement for web)
Face and subject safety checks (AI flagging but human confirmation)
Metadata completeness (copyright, credit, alt-text placeholder)
Maximum file size vs LCP budget

Optimization pipeline (practical)

Use libvips (fast, memory-efficient) or Sharp for Node.js. Example Node snippet: generate multi-size AVIF/WebP/JPEG variants, strip PII from metadata, and produce an audit log:

const sharp = require('sharp')

async function process(filePath, outBase) {
  const sizes = [1920, 1280, 800, 400]
  for (const w of sizes) {
    await sharp(filePath)
      .resize({width: w})
      .toFormat('avif', {quality: 70})
      .toFile(`${outBase}_${w}.avif`)
    await sharp(filePath)
      .resize({width: w})
      .jpeg({quality: 80})
      .toFile(`${outBase}_${w}.jpg`)
  }
}

process('/processing/STREAMF24_hero_raw.tif','/output/STREAMF24_hero')

Tip: keep the original high-bit-depth source in cold storage for future re-crops and legal checks.

Step 5 — Review & approval pipeline: parallelize and shorten loops

Design the approval pipeline so stakeholders can review the same proxy assets at once. Best practices:

Use single-source-of-truth review tools (Frame.io, Figma, or DAM in-review) that support frame-accurate comments
Route reviews in parallel: Legal, Creative Director, Localization lead
Use automatic reminders aligned with campaign launch times
Keep an audit trail (who approved what, when, and with what comments)

Approval gate example (webhook-driven)

{
  "assetId":"STREAMF24_hero_UK_v02",
  "reviews":{
    "creative":"approved",
    "legal":"pending",
    "localization":"changes_requested"
  }
}

Use the webhook to unpause transforms only after all gates are clear. That prevents premature publication of tentative variants.

Step 6 — Localization & territory variants: metadata-first strategy

Treat each territory variant as a metadata-driven presentation rather than a new source image when possible. Use templates for text overlays and automate per-territory rendering for language and legal copy.

Variant manifest (example)

{
  "assetId":"STREAMF24_hero",
  "variants":[
    {"territory":"UK","file":"STREAMF24_hero_UK_v02.avif","alt":"Hero image for UK"},
    {"territory":"FR","file":"STREAMF24_hero_FR_v01.avif","alt":"Visuel FR"}
  ]
}

When to create bespoke assets: unique local key art, different talent, or regulatory text. Otherwise, prefer overlay templates to reduce storage and review overhead.

Step 7 — Publish: connect CMS, CDN & on-the-fly transforms

Integrate with your headless CMS so the canonical asset record points to the CDN’s transformation URL rather than a static path. Benefits:

One master file, many responsive renditions
Reduced storage footprint
Better cache hit ratio across pages

Publish example — canonical URL pattern

Canonical stored file: https://cdn.yourorg.com/master/STREAMF24_hero.avif

Serving URL from CMS: https://cdn.yourorg.com/fit-in/1280x720/filters:format(webp)/master/STREAMF24_hero.avif

Cache invalidation: ensure your pipeline issues a purge when a variant is reapproved. Automate using CDN APIs from your CI system.

Step 8 — Monitoring & post-mortem: measure what matters

Track the following KPIs per campaign and territory:

Time from request to publish (goal: compress by 30–50% vs baseline)
Average asset file size and LCP contribution
Approval loop time per stakeholder
Number of manual interventions per 100 assets

Run a post-mortem — not to blame, but to optimize the spec and templates for the next campaign.

Practical templates & automation examples

Below are compact, copy-paste-ready blocks you can drop into your pipeline.

GitHub Actions: run image processing on push

name: Image pipeline
on:
  push:
    paths:
      - 'assets/**'
jobs:
  process:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install dependencies
        run: npm ci
      - name: Run processing script
        run: node scripts/process-assets.js
      - name: Call CDN purge
        run: curl -X POST https://api.cdn.example.com/purge -d '{"path":"/master/*"}'

Source provided as 16-bit TIFF or RAW
Delivery formats: AVIF + JPEG backups
Min width 2000px for hero images
Color space: sRGB
Embedded rights metadata present (IPTC/Credit/License URL)
Alt text draft attached
Localized text layer provided (if Full Localize)

Scenario: a VP commissions a fall launch for 12 territories with localized taglines and three image sizes per territory. With a manual process the team typically spends 12 workdays from request to publish. Using the workflow above:

Automated ingest & QC trims 2 days
Parallel review gates trim another 3 days
Template-based localization reduces bespoke work by 60%
On-the-fly CDN transforms remove the need to store 36 separate files per asset

Net result: time-to-publish drops from 12 days to ~4–5 days and engineering and storage costs both fall, while legal risk reduces because metadata and license windows are checked automatically before publish.

Governance, rights and metadata: don’t leave this to chance

Embed the rights matrix and IPTC/XMP fields into your ingest validation. When rights expire, automate asset unpublishing or place assets in a “review pending” state. Keep a permanent audit trail for takedown and brand compliance.

Rule: if metadata is missing, the file cannot be published. Automate the block and nudge the owner to fix it.

Advanced strategies: when to push the envelope

AI-assisted variant generation: use models to preview localized crops and text overlays, then send only the selected variants for human signoff.
Edge-resizing with A/B variants: experiment with slightly lower quality for low-visibility creatives to save bandwidth.
Progressive rollouts: publish to a single territory first, monitor KPIs, then roll out changes if engagement meets thresholds.

Common pitfalls and how to avoid them

Over-producing bespoke variants — prefer templates and overlays
Lack of canonical master files — always keep the high-res original immutable
Manual approval bottlenecks — parallelize and automate reminders
Ignoring metadata — treat IPTC/XMP as legally significant fields

Final checklist before go-live

All assets have a master file in cold storage
Automated QC passed or human signoff logged
CDN purge workflow tested and scripted
Localization templates tested for overflow and truncation
Monitoring dashboards set (LCP, file size, approval times)

Closing — future-proofing your creative pipeline (2026 and beyond)

Through late 2025 and into 2026 the maturation of CDN transformations, AVIF/WebP adoption and AI-assisted review will make manual, per-territory, per-size workflows obsolete. The teams that win are those who define rules-based pipelines, keep a single high-fidelity master, and embed rights & metadata checks at ingest. For commissioners and VPs, that means demanding structured briefs and investing a small fraction of campaign cost in automation — and you’ll save weeks on large global rollouts.

Actionable takeaways

Create a mandatory request template that includes rights, territories and acceptance criteria.
Use a watch-folder + automated QC pipeline (libvips/Sharp) to generate AVIF and JPEG variants.
Parallelize reviews — Legal, Creative and Localization at once — and gate publication on metadata completeness.
Connect your CMS to CDN on-the-fly transforms; store only the master source.
Set KPIs around time-to-publish, LCP contribution, and manual interventions and review monthly.

Call to action

If you’re leading creative operations for a global campaign, start by standardizing your brief today. Download our ready-to-use JSON request template and GitHub Actions starter workflow at jpeg.top/workflows (or contact our team for a 30-minute pipeline audit). Move from reactive handoffs to proactive, automated publishing — and cut your campaign delivery time in half.