How to Collaborate on Architecture Files Across Teams and Firms

What Makes Architecture File Collaboration Different

Architecture file collaboration is the practice of sharing CAD drawings, BIM models, renderings, and project documentation between architects, engineers, consultants, contractors, and clients throughout a design and construction project.

Unlike typical business file sharing, architecture collaboration has specific challenges:

• File sizes are massive: Revit models regularly exceed 500MB, sometimes reaching several gigabytes with linked files
• Files have complex dependencies: CAD drawings use external references (Xrefs) that break when shared incorrectly
• Version control is critical: 25% of design errors stem from version control failures
• Stakeholder count is high: A typical commercial project involves 50+ parties needing file access
• Formats are specialized: .rvt, .dwg, .3dm, .pln, and .skp files require specific software to open

Standard email fails at 25MB attachments. Consumer cloud storage wasn't built for linked file structures or professional CAD formats. That gap between what architects need and what typical sharing tools offer is where projects run into trouble.

Architecture File Types and Their Collaboration Needs

Different file types require different collaboration strategies. Understanding these distinctions prevents the sharing mistakes that cause rework.

BIM Models (Revit, ArchiCAD)

Revit (.rvt) and ArchiCAD (.pln) files are databases, not just drawings. They contain 3D geometry, material specifications, scheduling data, and parametric relationships. A single central model can exceed 500MB and may link to dozens of family files and external references.

Collaboration requirements:

• Strict version control to prevent database corruption
• Clear "detach from central" procedures for external sharing
• Ability to purge and audit before distribution

CAD Drawings (AutoCAD, MicroStation)

AutoCAD (.dwg) and MicroStation (.dgn) files use external references (Xrefs) to link background drawings, title blocks, and shared content. Sending the main file without its references results in a broken drawing.

Collaboration requirements:

• Package files with all dependencies using eTransmit or similar tools
• Maintain relative path structures when compressing
• Verify all links resolve before sending

3D Visualization Files (Rhino, SketchUp)

Rhino (.3dm) and SketchUp (.skp) models grow large with textures and complex geometry. Rendering files with high-resolution textures can exceed 10GB.

Collaboration requirements:

• Fast upload and download speeds for iterative sharing
• Preview capabilities so recipients can view before downloading
• Compression options for draft sharing

Why Traditional Sharing Methods Fail for Architecture

Most architecture firms have tried these approaches and hit the same walls.

Email and WeTransfer

Email attachments cap at 25MB, ruling out almost every CAD or BIM file. Services like WeTransfer handle larger files but create dead-end copies. When you send a Revit model, you lose track of which version exists where. Recipients download, make changes, and suddenly there are three versions of the same file with no clear lineage.

Shared Network Drives

Internal servers work for co-located teams but fail when projects involve external consultants. Setting up VPN access for every structural engineer and MEP consultant is slow and creates security overhead. Performance degrades when remote users try to open large files over slow connections.

BIM Cloud Platforms

BIM 360 and BIMcloud are essential for real-time model collaboration within a design team. But they're often too expensive or complex for casual stakeholders. A client who needs to view renderings shouldn't need a BIM 360 license. A one-time consultant shouldn't need training on Graphisoft's cloud interface.

Consumer Cloud Storage

Dropbox and Google Drive handle file sync but weren't designed for architecture workflows:

• Sync conflicts corrupt complex files when multiple users edit simultaneously
• No native preview for .dwg, .rvt, or .3dm formats
• Sharing permissions are too coarse (all-or-nothing folder access)
• Per-user pricing makes external sharing expensive

The gap is clear: firms need BIM platforms for internal design work AND a separate system for external file delivery to clients, contractors, and consultants.

How Architects Share Large Files With External Parties

External file sharing is where most architecture collaboration breaks down. Here's how to structure it properly.

Create Outgoing Folders by Recipient

Don't share your working folder structure externally. Instead, create dedicated "Outgoing" folders for each party:

Project/
├── Working/           ← Internal team only
├── Outgoing/
│   ├── Client/        ← Renderings, presentations
│   ├── Structural/    ← Backgrounds for coordination
│   ├── MEP/           ← Coordination files
│   └── Contractor/    ← Bid documents, construction sets

This structure lets you control exactly what each party sees. The structural engineer gets architectural backgrounds without seeing your design iterations. The client sees polished deliverables without wading through working files.

Detach and Purge Before Sharing

Before sharing Revit models externally:

1. Detach from central to create a standalone copy
2. Audit the file to fix any errors
3. Purge unused elements to reduce file size
4. Remove internal worksets or phases not needed by the recipient

This prevents accidental writes back to your central model and reduces file size by 30-50%.

Package CAD Files Properly

Use AutoCAD's eTransmit feature to package drawings with their Xrefs. This ensures:

• All linked files are included
• Paths are converted to relative so links don't break
• Fonts and plot styles are bundled
• The recipient gets a complete, working drawing set

Version Control for Architecture Coordination

Version confusion causes 25% of design errors according to industry research. Here's how to prevent it.

Use Revision Codes, Not "Final" Labels

Never use "final," "new," or "updated" in filenames. Instead, use a systematic naming convention:

[Project]-[Discipline]-[Type]-[Sheet]-[Rev]
Example: PRJ-A-PLAN-A101-RevC.dwg

When everyone follows the same convention, files sort correctly and anyone can identify the current version at a glance.

Track Revisions with a Log

Maintain a revision log that records:

• Revision code and date
• What changed
• Who authorized the change
• Who received the updated file

This log becomes critical documentation if there's ever a dispute about which version a contractor built from.

Supersede Rather Than Delete

When a new revision replaces an old one, don't delete the previous version. Archive it with a clear "superseded" marker. You may need to reference old versions for change order documentation or to understand the project history.

Set Automatic Notifications

The best version control means nothing if recipients don't know about updates. Use a system that notifies stakeholders when files change. Email notifications should include:

• Which file changed
• What the revision covers
• How to access the new version

Folder Structure Standards for Architecture Projects

A consistent folder structure ensures any team member or consultant can find files without hunting.

ISO 19650 Simplified

The ISO 19650 standard for construction information management provides a framework. A practical implementation uses four main containers:

• WIP (Work in Progress): Internal team files, incomplete work, explorations
• Shared: Verified files shared with project consultants for coordination
• Published: Approved deliverables for client, contractor, or regulatory submission
• Archive: Historical versions and superseded documents

Within each container, organize by discipline:

Published/
├── A_Architectural/
│   ├── Drawings/
│   ├── Specifications/
│   └── Renderings/
├── S_Structural/
├── M_Mechanical/
├── E_Electrical/
└── P_Plumbing/

Numbering for Sort Order

Use numbered prefixes to control sort order:

01_Admin/
02_Design/
03_Coordination/
04_Construction/
05_Closeout/

This keeps folders in logical project phase order rather than alphabetical.

Template for New Projects

Create a project folder template that every project starts from. This ensures consistency across your practice and reduces setup time for new jobs.

Security and Access Control for Architecture Files

Your designs are intellectual property worth protecting. External sharing needs proper access controls.

Granular Permissions

Give each party access only to what they need:

• Clients: View renderings and presentations, no editable files
• Consultants: Access to coordination files for their discipline only
• Contractors: Bid sets and construction documents, not design development

Avoid giving blanket access to your entire project folder. One misconfigured share can expose pricing, internal communications, or design alternatives you don't want visible.

Link Controls

When sharing via links, use available protections:

• Passwords for sensitive documents like contracts or fee proposals
• Expiration dates so links stop working after project milestones
• View-only mode for files that shouldn't be downloaded and circulated
• Watermarking to track document sources if leaks occur

Audit Trails

Use a system that logs who accessed what and when. This documentation matters for:

• Proving a contractor received updated drawings
• Demonstrating delivery of required submittals
• Tracking who downloaded fee proposals during negotiations

Fast.io provides granular permissions, link controls with password protection and expiration, and comprehensive audit logs that track every view and download.

Mobile Access for Field Coordination

Architecture doesn't stay in the office. Site visits, consultant meetings, and client presentations require mobile file access.

What Mobile Access Requires

• Fast loading: Nobody waits 5 minutes for a 200MB drawing to download on cellular
• Zoom and pan: Drawings must be readable on phone screens
• Offline mode: Construction sites often have spotty connectivity
• Search: Find the right sheet among hundreds of drawings

Common Mobile Problems

Most desktop-focused systems fail on mobile because:

• Files must fully download before viewing
• Interfaces require large screens to navigate
• No offline caching for poor connectivity
• Sync clients drain battery

Cloud-native systems that stream files on demand solve these problems. View a large PDF or drawing without downloading the full file. Cache specific files for offline access when visiting sites without connectivity.

Presenting to Clients

Mobile access also matters for client meetings. Pull up a rendering or walkthrough video on a tablet during a site visit. Stream video presentations without downloading gigabytes of footage first.

Setting Up Fast.io for Architecture Collaboration

Fast.io addresses the specific needs of architecture file collaboration: large files, external sharing, and mobile access without per-user costs.

For External Sharing

Create shared folders for each external party. Upload coordination files, and recipients access them through a clean branded portal without needing accounts. When you update a file, they see the new version automatically.

Link controls let you:

• Set passwords on sensitive folders
• Expire access after project phases
• Restrict to view-only when appropriate
• Track who accessed what through audit logs

For Client Deliverables

Upload renderings and presentation materials to a client-facing workspace. Clients view high-resolution images and stream video walkthroughs directly in their browser. No app installations, no account creation, no confusion about which file is current.

Custom branding puts your firm's logo on every page.

For Large File Handling

Upload Revit models and packaged CAD sets regardless of size. Fast.io uses cloud-native streaming rather than sync, so large files are available immediately without download bottlenecks.

Universal previews display CAD and PDF files in the browser. Consultants can check drawings without owning the software that created them.