Published in Articles
Creative asset management: folder architecture, naming and access that survive growth

Creative asset management at scale comes down to three decisions, made once and then enforced. Where the boundary sits between working files and delivered assets. What a filename means to somebody who did not create it. Who is allowed to view, upload and move things.
Storage is cheap and getting cheaper. Retrieval mistakes and permission mistakes are what cost you, because they surface days later as a re-edit, a wrong export, or a client opening an internal cut. That is the governance layer, and it looks roughly the same whether you run a shared Drive, a review platform, or both.
The boundary comes before the folder tree
Most broken libraries fail at one point: nobody ever decided when a file stops being a working file and becomes a delivered asset. So the same video exists in four places — the editor's project folder, a shared Exports folder, an email attachment, and a card — and nobody can say which one the client approved.
Split storage into roots with different rules:
- Working. Mutable, project-scoped, internal only. Footage, project files, rough exports, scratch audio. Nothing here is ever the record of what shipped.
- Delivered. Frozen, client-scoped, shareable. One canonical file per deliverable per version. A file leaves this root only by taking a new version, never by appearing under a new name.
- Brand or evergreen. Logos, fonts, licences, templates, guidelines. Long-lived, rarely touched, referenced by many projects at once.
Three roots is usually enough. The value is not the exact number. It is that every file has one obvious home and one obvious rule about whether it may still change.
Three folder architectures, and where each one cracks
Inside the Working root you need a second level. There are three common shapes, and each is the right answer for a different kind of business.
| Structure | Example path | Works when | Breaks when |
|---|---|---|---|
| Client-first | /Working/acme/2026-03-launch | You hold 5–25 ongoing clients and knowledge lives by account | A project serves two clients, or one client reaches 30 projects and the folder becomes a scroll |
| Project-first | /Working/2026-014-acme-launch | High project turnover and contract-based work, with editors joining and leaving | You need everything for one client in a single view, or a series spans several projects |
| Date-first | /Working/2026/03/ | Archive and retention rules matter more than daily retrieval | Anyone has to find a file by name rather than by remembering when it was made |
The hybrid that holds up best for creative teams is client-first at the top of the Delivered root and project-first inside Working, joined by a shared project code. A file named acme-launch-film_v03_20260402_delivered.mp4, sitting in /Delivered/acme/2026-03-launch/, traces back to /Working/2026-014-acme-launch/ without a lookup spreadsheet.
Do not restructure everything at once. Convert one active project end to end, use it as the reference, and let the rest migrate as it is touched.
Asset library migration checklist
Convert one active project to a governed structure before rolling the conventions out across the library
A naming convention that survives a handoff
Naming conventions fail for one reason: they try to carry status and version in the same token, so people write final_v2_FINAL_DO_NOT_USE.mp4 and hope. Separate the fields. Four are usually enough:
- Project code — short, lowercase, no spaces: acme-launch-film.
- Version — v01, v02, v03. Two digits, so sorting keeps working past nine.
- Date — YYYYMMDD, the day that version was created.
- State — one of working, review, approved, delivered, archived.
The delimiter matters less than consistency. Pick underscores or hyphens, write the whole rule on one line in a document the team can find, and never mix. If your team already has a convention that mostly works, keep it and add the missing field rather than replacing the lot.
Assume a revision chain of six rounds. With ad-hoc naming you typically end up with twelve to fifteen video files spread across folders, chat and email, several of them called final, and no reliable way to know which one was signed off. With the four fields you have six files, each carrying its own state, and exactly one of them in the Delivered root. The revision chain was never the problem — the missing record was.
One rule prevents most of the mess: final is a state, not a version. A file can be version 7 and still be working. The moment final becomes part of a filename, version numbers stop meaning anything.
Access tiers: who can view, upload and move
Permission design follows the roots, not the org chart. Working files are internal. Delivered assets are the only thing an outside person should ever touch.
Three tiers cover nearly everything:
- Full members. Can see all projects, upload anywhere in Working, and move files between stages. This group can break things, so keep it small.
- Contractors and editors. Restricted to the work they are assigned. In kloudboard, card visibility is enforced server-side: a guest without the view-all-cards permission sees only the cards assigned to them, so an unassigned card is simply invisible. The setup sequence is covered in giving freelance editors access to only their assigned projects.
- Clients. Review access to specific deliverables and nothing else. They should never hold a permission that lets them browse the Working root.
The detail people get wrong is Drive access for contractors. Drive Viewer permits viewing, downloading and commenting, but not uploading. Editor is the level that allows uploads, and it is granted per person in Settings > Team alongside a folder share. Without See all files, a guest's Drive visibility is limited to the folders shared with them, which is the containment you want. If you need to hand an editor somewhere to drop footage without exposing the rest of the library, sharing files with freelance editors without full Drive access walks through that split.
Guests are free and do not count as paid seats, so the cost calculation is not what should decide this. The permission itself is. Test it with a real deliverable before a deadline tests it for you: invite one guest, assign one card, share one folder, then check what they can and cannot see. A missing permission looks exactly like a broken link until you look.
Version control: where the truth lives
A library is only as good as its answer to which file is current. Pick one canonical file per deliverable and let that file accumulate versions, rather than spawning near-identical siblings.
In kloudboard, files attached to a card are stored in the workspace Drive, so an editor's draft can be reorganised in Drive without breaking the card link. Uploading a new version to the same file preserves the earlier ones, and reviewers can switch between them instead of hunting for a filename. That behaviour is the reason to attach the review copy to the card rather than dropping a fresh file into a folder and describing it in chat.
Two conventions make version history usable:
- One file per deliverable per client. New round, new version of the same file. Never a copy suffixed with edited or final.
- Notes belong to a version. Feedback left against version 3 is meaningless once version 5 exists, so keep the review attached to the file it critiques. A creative approval workflow built on file version history keeps card status, comments and versions pointing at the same artifact.
Opening a card and using the Review action beside an attached video or PDF gives you timestamped comments and mentions on the asset itself. That is the difference between the bit near the start feels slow and a note an editor can act on without a call.
Worked example: a studio splitting working from delivered
Assume a studio with 18 active clients and 25 projects a year. Say working files average 60 GB per project, and delivered output averages 1.5 GB per export variant across four variants. Working storage grows by about 1.5 TB a year; delivered assets by about 150 GB. A roughly ten-to-one ratio, which is the whole argument for giving the two roots different rules.
Their tree after the split:
- /Working/2026-014-acme-launch/01-footage, 02-project-files, 03-exports
- /Delivered/acme/2026-03-launch/acme-launch-film_v03_20260402_delivered.mp4
- /Brand/acme/logos, /Brand/acme/fonts, /Brand/acme/guidelines
The daily handoff: the editor exports into 03-exports in Working and attaches that file to the project card with state review. Feedback happens on the card, against that version. When the cut is approved, the export is re-uploaded as a new version of the canonical file in Delivered and the state becomes delivered. Working keeps its scratch files; Delivered keeps the record; nothing is duplicated; no client ever holds a link into the Working root.
Automation can carry part of this. A Drive upload can trigger a board automation — notifying the assignee when a new export lands, for instance — but treat that as a nudge, not as governance. The convention still has to exist, and the automation only reminds people it does.
What to do today
Do not redesign the whole library. Take one active project. Write the boundary sentence down — one line on what counts as a delivered asset. Create that project's Delivered folder, rename its files into the four-field convention, move the approved export out of Working, and remove the near-duplicates. Then invite one external collaborator at the smallest permission that still lets them work, and verify what they actually see.
If you want the plumbing view of how the shared library, folders and permissions fit together, the asset management product page is the short version. For the client-facing side of the same structure, organizing a client asset library that scales covers handoff and access in more detail.
One project is enough to discover which of your conventions nobody will follow. Better to learn that on project fourteen than on delivery day.
Related articles
The workspace for creative teams
Manage projects, pay your team, and ship content faster.
Start for free