Upload large file with chunked upload

Remote design agencies face a unique challenge: moving massive creative assets across distributed teams without bottlenecks. When your team spans multiple time zones and your files routinely exceed gigabytes, traditional cloud storage often falls short. This guide evaluates solutions that actually work for agencies handling large design files, with technical implementation details for developers integrating these tools into existing workflows.

The Core Problem: Latency and Version Control

Design files differ fundamentally from code. A Figma export might be 500MB; a video render could hit 10GB. Standard cloud drives attempt to sync these files globally, often resulting in team members working with stale versions or burning bandwidth on constant re-uploads. The best solutions for remote agencies address three concerns: selective sync for bandwidth management, version history, and direct integration with creative tools.

Dropbox: Selective Sync at Scale

Dropbox remains a solid choice for agencies prioritizing bandwidth efficiency. Its selective sync feature allows team members to choose which folders sync locally, preventing 50GB folders from filling laptop SSDs. The Smart Sync feature automatically keeps recently accessed files available offline while streaming older assets on demand.

For integration, Dropbox offers a REST API with straightforward authentication:

import dropbox

dbx = dropbox.Dropbox("YOUR_ACCESS_TOKEN")

# Upload large file with chunked upload
def upload_large_file(file_path, destination):
    with open(file_path, 'rb') as f:
        file_size = os.path.getsize(file_path)
        CHUNK_SIZE = 8 * 1024 * 1024  # 8MB chunks

        if file_size <= CHUNK_SIZE:
            dbx.files_upload(f.read(), destination)
        else:
            # For files larger than 8MB
            upload_session = dbx.files_upload_session_start(
                f.read(CHUNK_SIZE)
            )
            cursor = dropbox.files.UploadSessionCursor(
                session_id=upload_session.session_id,
                offset=f.tell()
            )

            while f.tell() < file_size:
                dbx.files_upload_session_append_v2(
                    cursor, f.read(CHUNK_SIZE)
                )
                cursor.offset = f.tell()

            dbx.files_upload_session_finish(
                cursor, f.read(), dropbox.files.CommitInfo(destination)
            )

Dropbox lacks granular role-based access controls compared to enterprise alternatives, and its collaboration features are more suited to file sharing than live design feedback.

Google Drive: Native Integration, Moderate Limits

Google Drive works well for agencies already embedded in the Google Workspace ecosystem. Its real-time collaboration on Google Docs and Sheets transfers to shared folders, and the integration with Figma and other web-based tools is. However, individual file size limits (5TB for single files) can constrain large video or 3D asset workflows.

Drive’s API enables programmatic file management:

const { google } = require('googleapis');
const auth = new google.auth.GoogleAuth({
  keyFile: 'credentials.json',
  scopes: ['https://www.googleapis.com/auth/drive'],
});

const drive = google.drive({ version: 'v3', auth });

// Upload large file using resumable upload
async function uploadLargeFile(filePath, folderId) {
  const response = await drive.files.create({
    requestBody: {
      name: 'design-assets.zip',
      parents: [folderId],
    },
    media: {
      body: fs.createReadStream(filePath),
    },
  });
  return response.data;
}

// List files larger than 100MB to identify bandwidth-heavy assets
async function findLargeFiles(folderId) {
  const response = await drive.files.list({
    q: `'${folderId}' in parents and size > 104857600`,
    fields: 'files(id, name, size, modifiedTime)',
  });
  return response.data.files;
}

The limitation: Google Drive’s sync client can struggle with thousands of small files, and its version history (limited to 30 days on most plans) may not satisfy agencies requiring longer audit trails.

Box: Enterprise-Grade Security

Box positions itself as the enterprise file management solution, with compliance certifications that matter for agencies handling client work under NDA. Its granular permissions, watermarking, and detailed audit logs exceed what Dropbox or Google Drive provide out of the box.

For remote agencies with strict security requirements, Box’s wrapper API provides sophisticated access control:

from boxsdk import Client, OAuth2

auth = OAuth2(
    client_id='YOUR_CLIENT_ID',
    client_secret='YOUR_CLIENT_SECRET',
    access_token='YOUR_ACCESS_TOKEN',
)

client = Client(auth)

# Create folder with specific collaboration settings
def create_project_folder(parent_folder_id, project_name):
    folder = client.folder(parent_folder_id).create_subfolder(project_name)

    # Set folder metadata for project tracking
    folder.metadata().create({
        '/project_name': project_name,
        '/client_confidential': True,
        '/retention_period_days': 365
    })

    # Invite specific team members with custom role
    collaboration = folder.add_collaborator(
        'designer@agency.com',
        role='editor'
    )

    return folder

# Get download links for assets expiring in 24 hours
def generate_expiring_links(folder_id, expiry_hours=24):
    folder = client.folder(folder_id)
    items = folder.get_items()

    links = []
    for item in items:
        if item.type == 'file':
            link = item.get_shared_link(
                access='open',
                expires=(datetime.now() + timedelta(hours=expiry_hours))
            )
            links.append({'name': item.name, 'url': link})

    return links

Box’s drawback is its steeper learning curve and less intuitive interface compared to consumer-focused alternatives. The sync client also consumes more system resources.

Rclone: The Developer-First Approach

For technical teams comfortable with command-line tools, rclone offers unparalleled flexibility. This open-source CLI tool connects to over 70 cloud storage providers, allowing agencies to bridge multiple storage backends without committing to a single vendor.

Rclone excels at bandwidth-efficient sync and can filter which file types transfer:

# Sync only design files (PSD, AI, FIG, SKETCH) to remote
rclone sync ./designs remote:bucket/designs \
  --include "*.psd" \
  --include "*.ai" \
  --include "*.fig" \
  --include "*.sketch" \
  --include "*.xd" \
  --exclude "*" \
  --transfers 4 \
  --bwlimit "10M" \
  --progress

# Mount remote storage as local filesystem (for creative tools)
rclone mount remote:bucket/designs /Users/team/designs \
  --vfs-cache-mode writes \
  --vfs-cache-max-age 24h \
  --attr-timeout 1s

The mount feature lets creative applications access cloud storage directly, though performance varies based on network conditions. Rclone requires more setup than turnkey solutions but rewards technical teams with complete control.

Which Solution Fits Your Agency?

Choose Dropbox if your team prioritizes simplicity and cross-platform sync with selective folder control. Select Google Drive if you’re already embedded in Google’s ecosystem and need real-time document collaboration alongside design assets. Pick Box when compliance requirements demand enterprise-grade security and audit trails. Opt for rclone when you need to bridge multiple storage providers or want CLI-driven automation.

For most remote design agencies, a hybrid approach works best: Dropbox or Google Drive for active projects requiring collaboration, with rclone scripts handling archival to cheaper cold storage. The key is ensuring your file sharing solution supports selective sync, maintains reliable version history, and integrates with your existing creative tooling without forcing workflow changes.

Built by theluckystrike — More at zovo.one