Getting from scattered folders to something you can actually search

The outcome worth aiming for isn't a tidier folder tree — it's being able to type a sentence-shaped line and get back exactly the images that match, regardless of which folder they happen to sit in today. That's a different project from renaming and re-filing everything, and it takes an afternoon rather than a weekend, because the folders you already have are the starting point rather than the problem to solve first.

Most guides to organising a Mac's images start from the assumption that the current structure is wrong and needs fixing before anything else can happen. That assumption is usually what stalls the whole project — reorganising several years of folders is exactly the kind of task that never gets finished, so it becomes the reason nothing gets searched in the meantime. The steps below skip it entirely.

They're also written in the order that actually works rather than the order that sounds tidiest on a checklist. Indexing comes before tagging, because indexing needs nothing from you and pays off immediately, while tagging is ongoing and optional. Saving searches comes near the end, because a search is only worth saving once you've typed it and confirmed it answers the question you actually had — saving one earlier is guessing at a need you haven't tested yet.

Step 1: Don't reorganise first

The instinct when a folder feels messy is to fix the folders. Resist it. Coii Ref indexes whatever structure already exists — client folders, project folders, a dumping ground called "unsorted" that everyone has one of — and none of it needs to change before the app can search it. Reorganising is optional cleanup you can do later, once search means you no longer have to, and most people find they never bother once the search actually works.

This matters more than it sounds like it should, because the alternative — tools that ask you to import into a new library structure — turns organising into a two-step project: first move everything into the new shape, then start actually using it. Indexing in place collapses that into one step, and it's the reason the folder named "Unsorted" doesn't need to be renamed before it's useful.

Step 2: Point it at the root folder, not every subfolder

Register the top-level folder as a workspace rather than picking individual subfolders one at a time. A single root that covers "Client shoots," "Moodboard sources" and "Unsorted" gets you one search across all three from the first pass, instead of three separate libraries you'd have to check one at a time. If your references live on more than one drive, each drive gets its own root — a workspace doesn't span across drives, since the database and thumbnails it writes live beside the files on that same drive.

The choice of root matters more than the choice of subfolder names beneath it. Pick the folder one level above where the real variety starts — not so high that unrelated files get swept in, not so low that you end up registering five separate workspaces for what is really one collection. A reasonable rule of thumb: if you'd naturally call two subfolders "part of the same collection" when describing them to somebody else, they belong under the same root rather than split into two workspaces that can't be searched together in one query.

Step 3: Let the first pass read what's already true

Indexing reads each file's dimensions, EXIF and colour without asking you to label anything. This is the part that pays off before you've tagged a single image: a folder full of unsorted screenshots and photographs is already searchable by type, size and date the moment the first pass finishes, which is often the single biggest jump in usefulness the whole process produces.

How long the first pass takes depends on how many files there are and whether they're on an external drive or the internal one, but it's a one-time cost per root: after it finishes, the ongoing work is maintenance rather than another full scan. This is also the point where it's worth doing the sanity check described further down — comparing a rough total against what Finder itself reports for the same folder, so a permissions problem or an unsupported file type gets caught early rather than discovered as a gap three months later.

Step 4: Tag a little, not everything

Tagging every image in a large folder is a project that never finishes and quietly makes people stop collecting, because the backlog grows faster than anyone can clear it by hand. Tag the handful of things that matter for how you'll actually search later — a project name, a mood, a status like "approved" — and leave the rest to file type, dimensions and dates, which need no typing at all. The tags-versus-folders question covers which jobs each one is actually good at, and it's worth reading before deciding how much tagging effort a given folder is actually owed.

A useful rule of thumb: if you can already answer the question you'd ask about a group of images using type, size, date or folder alone, that group doesn't need a tag. Save tagging effort for the genuinely subjective distinctions — the ones nothing about the file itself will ever reveal.

Step 5: Add ratings and notes where a tag would be overkill

A one-to-five rating and a short note both take less time than typing a tag and often carry more of what you meant. "Good pose, wrong lighting" as a note survives a lot better than trying to invent a tag for it, and it doesn't pollute a tag vocabulary with a one-off phrase that will never apply to a second image. Reserve tags for things you'll search by name later; use ratings for quality and notes for context that's specific to one image rather than a category several images share.

This division does more work than it first appears to. A vocabulary of tags stays small and trustworthy precisely because ratings and notes have absorbed everything that doesn't belong in it — the quality judgments, the one-off observations, the reminders to yourself about a specific shot. Mixing all three into "tags" is the single most common reason a tagging system becomes unreliable within a year.

Step 6: Save the searches you run more than once

The first time a query line answers a question well, save it as a view rather than retyping it next week.

A saved view stores the text of the search, not a snapshot of its results, so renaming a tag later doesn't leave the view stale — it just follows the rename. What a smart folder is is the same idea under a different name, if that's the term you already think in, and it's worth building the habit of saving a view the second time you catch yourself typing the same query rather than the tenth.

Step 7: Let the watcher do the maintenance

Once the first pass is done, the folder watcher keeps the index true as you work the way you already do — renaming files in Finder, moving a project folder to another drive, plugging in an external drive you hadn't touched in a month. Filesystem events become the smallest re-scan that makes the database correct again, so none of that requires reopening the app or re-indexing anything by hand. It also keeps running after any trial period ends, deliberately, because an index that quietly falls out of date is worse than no index at all — at least a missing index is an honest kind of useless.

A worked example: a folder nobody has opened in a year

Say there's a folder called "Old shoots" on an external drive, roughly eight thousand images, untouched since a project wrapped. Registering it as its own workspace takes a minute; the first pass over eight thousand files takes longer, but it's a background task rather than something that blocks anything else you're doing on the machine in the meantime.

Once it finishes, the folder is immediately searchable by everything the first pass read — file type, dimensions, when each file was originally added to the disk, whether it's a still or a clip. None of that required opening a single image. A query for the largest, most recent files in that folder often turns up exactly the handful worth pulling forward into active work, without scrolling through the other seven thousand to find them.

From there, tagging is optional and can happen gradually: pull a shot onto a canvas for a new project, tag it in the moment, and move on. The folder never needed a dedicated tagging session to become useful again — it needed one index pass.

Common mistakes worth avoiding

A few patterns show up often enough to name directly. Renaming a whole folder tree to match a new scheme right before indexing it, rather than after — this just delays the payoff for no benefit, since the app doesn't care what the folders are called. Tagging retroactively in one long session rather than as you go — it burns an afternoon and the backlog usually wins anyway. And treating a tag and a folder as competing systems rather than complementary ones — a folder is still the right place for the one-time decision about where a shoot lives; a tag is for anything that decision doesn't capture.

How this fits with building a canvas

Organising the folders and building a board are two separate habits that end up feeding each other. A canvas doesn't need its plates tagged, rated or even filed anywhere in particular first — you can drag an untagged image straight from a freshly indexed folder onto a board, which means the two projects never block each other. In practice, most of the light tagging described in step four happens exactly at that moment: an image gets pulled onto a canvas for a specific reason, and that reason becomes the tag, rather than tagging happening as a separate pass disconnected from any actual use of the image.

Why the order above beats starting with tags

Starting with tagging feels productive because it looks like organising, but it's the slowest possible way to get to a searchable library — every image has to be looked at and labelled before it's findable at all. Starting with indexing gets the whole folder searchable by fact in one pass, with zero manual work, and tagging becomes something you layer on gradually rather than a prerequisite standing between you and a useful library.

What to do when the library gets large

The steps above don't change at forty thousand files across six drives; only the emphasis does. Tagging everything stops being realistic well before that point, so lean harder on dimensions, dates and type, and save more views rather than fewer — a saved view costs nothing to keep around and means never re-deriving a query you already got right once. If a search feels slow to construct, it usually means it's asking two unrelated questions at once; splitting it into two saved views is almost always faster than one long line, and it also makes each view more reusable on its own than a single query trying to do both jobs at once.

Reference manager for Mac covers the fuller feature set this workflow draws on, and Finder tags is the free version of the same idea if you're not sure yet whether you need more than what's already installed. The one-time-purchase shape of this tool specifically is worth reading if price is part of the decision, and the wider library has comparisons against refern, Eagle and PureRef if one of those is also on your list. Or skip ahead and try it on your own folders — thirty days, every feature, no card and no account, is enough time to run every step above against a real library rather than a hypothetical one, and none of it requires deciding on a final folder structure before starting.