Sanity Review

Sanity is a headless CMS where the structured-content model is code, the editing studio is a customizable React app, and the query layer (GROQ) is what most people stay for once they've tried it.

It's not a page builder. It's not a website-in-a-box. It's a content backend you wire up to whatever frontend stack you like — Astro, Next.js, Nuxt, Hugo, or your own React app. The Vibetoolstack site is built on Sanity. So is this review.

The schema-as-code model

In most CMSes, you click around to define content types, fields, and relationships. In Sanity, you write TypeScript files. This sounds harder. It's actually faster — schema in code means version control, migrations, type-safety, and a living spec that diffs cleanly across environments.

If you've ever tried to migrate Contentful or Strapi schema changes between dev/staging/prod, you'll appreciate the Sanity model the first time you do it.

GROQ vs GraphQL

Sanity ships both. GROQ is the native query language — concise, JSON-shaped, deeply expressive. GraphQL is a schema-generated bolt-on. GROQ wins on every dimension except the obvious one (familiarity). Most teams who try GROQ stay on it.

What works

• Schema flexibility is genuinely best-in-class. Reference fields, conditional schemas, computed fields, nested objects — you can model any content shape Sanity supports.
• Real-time collaboration is built in. Multiple editors on the same doc don't conflict. The editor sees who else is in the doc, what they're typing, and changes resolve cleanly.
• Studio is yours. You can customize the studio with React components, override field renderers, build custom desk structures, and add custom actions. Powerful when you need an opinionated editorial workflow.
• GROQ. Once you've used it, every other CMS query layer feels limited. Reference resolution, projections, joins, conditional projections — all in one query.
• Image pipeline is built in. Hotspots, responsive sizing, format negotiation, CDN. You don't think about image optimization.
• Plugin ecosystem is healthy. Multi-locale, scheduled publishing, comments, asset management — all available as drop-in plugins.

What doesn't

• Pricing scales with dataset use. The Free tier is generous, but $99/mo Growth has real limits (100K docs, 250GB bandwidth) that scaling content sites can hit.
• GraphQL is an afterthought. If you're committed to GraphQL across your stack, expect rough edges.
• Steep onboarding for non-developers. Editors love the studio once it's customized; setting it up requires React + TypeScript.
• No native page-builder. You'll model content as structured blocks (Portable Text). Visual page-building isn't the metaphor.

I've run Sanity in production for 18 months across three properties: Vibetoolstack (this site), Cropsharing (marketplace), and an internal content-pipeline app. About 1,200 documents in production at peak.

Where it consistently delivers

Schema migrations across environments. I changed the tool schema in this codebase six times during the build. Each migration was: edit the TypeScript file, run the migration command on dev dataset, verify, run on prod. Compare to Contentful where this would be a click-tour or a manual data migration.

GROQ for the deep queries. The /alternatives/[tool] page on this site needs to fetch a tool, dereference its alternatives refs, project specific fields, and order by VTS score — one GROQ query, six lines. The same query in GraphQL would be three resolvers and 30 lines of fragment composition.

Real-time collab. When Paul and a freelance editor work on a draft simultaneously (different sections of the same doc), Sanity handles it without conflicts. Worth real money for content teams.

Where it stumbled

The free tier's bandwidth ceiling. Vibetoolstack hit the 100GB/month bandwidth cap on the Free tier within the first 6 weeks of beta-launch traffic. Moving to Growth at $99/mo was inevitable but the cliff was sharper than the docs suggest.

Studio customization compounds. Custom field renderers, custom desk structures, plugin configs — all great in moderation. We over-customized the early Vibetoolstack studio and had to walk back about half of it. Sanity Studio defaults are good; deviate only when you measure a real workflow win.

18-month numbers

3 datasets (production + development + a sandbox), 1,200 documents at peak, 8 editors across two teams, zero data-loss incidents, zero downtime incidents. Two minor schema migration mistakes — caught in dev dataset before prod. Total cost: $99/mo Growth tier, no surprise bills.

When Sanity is the right pick

Content-scaled publications. If you're building a site that will have hundreds-to-thousands of structured documents (blog posts, product pages, reviews), Sanity's schema flexibility and GROQ pay off compounding interest.

Multi-property setups. If you're running 2+ sites that share content (e.g., a blog with cross-posting, or a multi-brand portfolio), Sanity's reference model and dataset architecture handle this cleanly.

Editorial-team operations. If you have content editors, freelancers, or contributors who need a real CMS UX (and not GitHub PRs), Sanity Studio with custom desk-structures is excellent. Comments, scheduled publishing, role-based permissions — all there.

Astro / Next.js / Nuxt frontends. Sanity has first-class plugins and previews for all the major static-site frameworks. Friction-free integration.

When something else wins

Fully visual sites. Webflow or Framer if your team designs in the browser and ships visual layouts.

Lightweight blogs. If you have one author and 10 posts, Sanity is over-engineered. A flat MDX file structure or even Notion-as-CMS is fine.

E-commerce-first. Shopify or a commerce-native headless platform handles cart/checkout/inventory better than Sanity will.

Sanity sits in the structured-content headless-CMS bucket. The honest alternatives:

• Contentful — the OG. More polished marketing, less schema flexibility, more expensive at scale.
• Strapi — open-source, self-hostable. Good if you need on-premise deployment; community plugins lag Sanity's.
• Hygraph (formerly GraphCMS) — GraphQL-first. Pick if your stack is GraphQL-committed.
• Notion as CMS — great for personal sites, breaks at content-team scale or when you need real schema.
• Payload CMS — newer, code-first like Sanity, self-hostable. Worth watching.

For a side-by-side breakdown, see the Sanity alternatives page.

Is Sanity good for blogs?

Yes, but it's overkill for tiny blogs. If you have 50+ posts, multiple editors, or you need structured fields beyond title/body, Sanity pays off. For a 10-post personal blog, MDX or Notion is faster to set up.

How does Sanity pricing actually work?

Free tier: 3 users, 10K docs, 100GB bandwidth. Growth at $99/mo: 20 users, 100K docs, 250GB bandwidth. Enterprise: custom. The two surprise variables are bandwidth (image-heavy sites blow through fast) and document count (large content libraries hit the cap).

Can I migrate from Contentful to Sanity?

Yes. There are migration scripts in the Sanity community for the common Contentful → Sanity case. Schema differences mean it's not push-button — expect a week of mapping work for a non-trivial library.

Does Sanity work with Astro?

Yes — first-class. The @sanity/astro integration handles the GROQ client, preview mode, and visual editing. Vibetoolstack runs on this stack.

What's the difference between GROQ and GraphQL?

GROQ is Sanity's native query language — concise, projection-based, supports references and joins natively. GraphQL is the standard query language Sanity also exposes via a schema-generated layer. For Sanity-specific work, GROQ is faster to write and more capable. For cross-system GraphQL, use the GraphQL endpoint.

Is Sanity Studio open source?

Yes. Sanity Studio (the editor) is MIT-licensed. The hosted backend (Sanity Content Lake) is Sanity's commercial product. You self-host the studio; the content backend is hosted by Sanity.