From 322 Errors to Zero: What Cleaning Up My Own Shopify Store Taught Me

I didn't learn this from a client. I learned it from a mess I made myself.

My store is Collage and Wood: about 162 handmade products.

Collages, wooden letters, signs, props, blankets.

Real inventory, real customers, real orders coming in the whole time.

It looked fine.

That was the problem.

When I finally audited it properly against a written spec, I found 322 taxonomy and feed violations sitting in a catalog I would have told you was in good shape.

What 322 violations actually looked like

Not one catastrophic failure.

Hundreds of small ones, which is worse, because nothing ever alerts you.

They fell into four piles: products with inconsistent metafields, or none at all, where the same idea was recorded three different ways or not recorded anywhere.

Missing required fields that Google needs before it will show a product.

Hand-curated collections that only contained what I remembered to add, so new products silently fell through and never appeared where customers were looking.

And products that belonged in a collection that didn't exist yet: the demand was there, the shelf wasn't.

None of that shows up on a dashboard.

There is no screen in Shopify that says your product data is inconsistent and it's costing you money.

The store loads.

The photos are good.

The orders come in.

The mess lives in the fields nobody looks at.

What I did, in the order I did it

The order matters more than any single step.

Do these out of sequence and you'll do the work twice.

Step one: I wrote the spec before I touched a product

One source of truth: a documented metafield taxonomy of 14 structured fields, chosen so that each one earns its keep in two places at once, on-site merchandising and the Google feed.

This is the part people want to skip, and it's the part that decides everything downstream.

Deciding what your products are, what questions you ask every product and what answers are allowed, is design work.

Names, namespaces, keys, allowed values.

Get it right once and every rule, filter, and feed built on top of it just works.

Get it wrong and you'll be cleaning up wedding, weddings, and Wedding forever.

That spec is now the thing I build first for every client. It's the service, not the paperwork.

And the spec can evolve with your store, but it holds the system accountable.

Step two: I edited a live store, and built a tool so that was survivable

There was no staging environment.

No dev store, no dry run.

Collage and Wood was taking orders the whole time I was working.

162 products is too many to fix by hand, and more than enough that a careless bulk edit would be a genuine disaster.

So I built the thing that made it safe.

I call it the Catalog Health Audit.

It reads the live catalog, checks every product against the spec, and for each violation it records two values: what's there now, and what it should be.

A material of "1/2 Inch Blondewood" becomes half-inch-blondewood.

Then it sorts every finding into one of three buckets: safe-fix, which is purely mechanical and needs no judgment.

Safe-fix-mapped, which needs a lookup I've already defined.

And needs-decision, where a human has to choose.

That's the review step.

Not a staging server: a written preview of every single change before it's made, in a file I can actually read.

Once I've approved it, the fixes are written straight back to Shopify.

The tool didn't just find the problems.

It's what let me fix them on a live store without holding my breath.

Step three: I replaced hand-curated collections with smart collections

This is where the store stopped fighting me.

Manual collections only contain what you remember to put in them.

Smart collections build themselves from a rule, and once every product carries clean metafield values, that rule always has something correct to read.

New product goes up, fills in its fields, and lands in the right collections on its own.

No curation.

Nothing lost.

Today 42 of my 45 collections maintain themselves, and 38 of those rules read a metafield.

Step four: I fixed the feed fields properly

With the taxonomy in place, the Google Shopping feed had real data to read instead of gaps and guesses.

Products stay approved and stay eligible, because the fields Google requires are actually populated, consistently, across the whole catalog.

The feed didn't need a clever hack. It needed the product data underneath it to be true.

Step five: I automated the audit so it can't drift back

This is the step that turns a cleanup into a system.

A cleanup is a snapshot.

Catalogs drift.

You add products, you get in a hurry, you skip a field.

So I stood up an automated audit that re-checks the live store against the spec and flags anything that's wandered off.

322 violations went to zero.

Against the spec I had written, the catalog was clean.

Then I made the standard harder

Here's the part I could quietly leave out, and won't.

Getting to zero didn't mean I was done. It meant my spec was done, and a spec is only as good as the questions it thinks to ask.

So I kept stress-testing it. I wrote a stricter version.

It added rules the first spec never checked: that values follow one casing and format convention, that every controlled field draws from an allowed list, that photo-bearing products actually carry a photo count.

Then I ran the new spec against the same 162 products.

542 violations. Zero products passing every rule.

That is not a regression.

Nothing broke.

The bar moved, and the audit immediately told me exactly how far the catalog was from the new bar, across 162 products, in the time it takes to run a script.

And here's the number that actually matters.

Of those 542 findings, 380 were pure mechanical fixes, casing and hyphenation, no judgment required.

Another 135 needed a simple lookup, turning "1/2 inch blondewood" into half-inch-blondewood.

Only 27 needed me to actually decide something.

27 decisions out of 542 findings.

That ratio is the whole argument for doing this properly.

A machine can't tell you what your products are.

That's taxonomy design, and that's human work.

But once you've decided, a machine can enforce it across your entire catalog forever, and hand you back only the handful of things that genuinely need a person.

That's what you're buying.

Not a tidy afternoon.

A standard that holds, and gets stricter as you get better.

The three things I'd tell you if we only had five minutes

A messy catalog doesn't look messy.

It looks like a store.

That's why it survives for years.

You will not notice this by browsing your own site.

You'll only see it when you check the fields against a written standard.

The structure is the product.

Everything customers see, collections, filters, what shows up in Google, is downstream of your product data.

Three systems, one set of fields.

Fix the fields and all three improve at once.

Skip them and all three break at once, quietly.

Cleaning up once is not the win. Having a standard is the win.

Anyone can fix a catalog on a good weekend.

The real test comes the day you decide to raise your standard.

If you have an audit, you hit run and know in seconds exactly how many products fall short.

If you don't, you never find out — you just go on assuming the catalog is fine, the way I did for years.

Frequently asked questions

How long does a cleanup like this take?

It depends entirely on catalog size and how much structure already exists. The sequence is what's fixed, not the timeline: spec first, then bulk-set the fields, then convert the collections, then the feed, then automate the check.

Skipping straight to the feed is why most cleanups don't hold.

Did you have to take the store offline?

No. The store took orders throughout. Changes were staged and reviewed before going live, which is the only responsible way to bulk-edit a catalog that customers are actively shopping.

Do I need an app to do this?

No. Metafield definitions and automated collections are built into Shopify. A feed app may still be worth having once your data is clean, but installing one first just means the mess travels further, faster.

Fix the fields, then decide what you need to buy.

Why 14 fields? Is that the right number for me?

Almost certainly not. Fourteen was right for my catalog.

The number falls out of your products and the reasons people buy them. The test for any field is whether you can say the sentence: I want a collection, a filter, or a feed of every product where this equals X.

If you can't, you don't need the field yet.

What if my catalog is much bigger than 162 products?

Then you need this more, and it's a bigger job. The mess scales with your catalog — more products, more places for values to drift, more revenue riding on getting it right.

The spec takes longer to design, too, because a larger catalog usually means more product families, more edge cases, and more decisions only a person can make.

And the risk of a careless bulk edit grows with every product you add. That's why the work is priced by catalog size. What doesn't change is the sequence: spec, then fields, then collections, then feed, then the audit that keeps it honest.

Want to know what's leaking on your store?

A Catalog Health Audit is the same diagnosis that found those 322 issues, run on your catalog: which fields exist, which are half-filled, and which values are too inconsistent to build anything on.

Or start free. The 5 Signs Your Shopify Feed Is Leaking Money checklist will show you in about five minutes where your product data is already costing you.

---

I'm Crystal.

I run my own Shopify store, collageandwood.com, where I took the catalog from 322 feed and taxonomy errors to zero and built the audit that tells me the moment it drifts.

Now I do the same for other Shopify stores.