Sanity CMS Review: Why We Use It for B2B Websites

The short answer

Sanity CMS is a headless CMS with a hosted content database (the "Content Lake"), an editor built in React called Sanity Studio, a real-time API and visual editing by clicking into a live preview. The website itself is not built in Sanity. It is built in a framework such as Astro or Next.js that pulls content through the API.

For B2B companies, Sanity combines three things that usually exclude each other: a content model with no item ceiling, shaped exactly around your content; an editor in which your marketing team works without a developer; and almost no recurring platform fees, because the free plan covers 10,000 documents and 20 seats.

The flip side: Sanity ships no design and no frontend. Every change to the content model is developer work. If you want to work without a development partner, Webflow serves you better. If you run content as a system, with several languages, growing knowledge sections and programmatic pages, Sanity gives you the open foundation for it.

How Sanity works: Content Lake, Studio, GROQ, webhooks

Four parts you should know before a developer sends you a proposal.

The Content Lake is the hosted database. Every piece of content is a document in JSON format: an article, a service page, a testimonial. Which fields a document has is defined by the schema, and your developer writes that in code. At LeanWave 64 documents and 86 images live this way, split into dedicated types for FAQs, posts, testimonials, case studies, and legal texts.

The Studio is the editor: a React application that builds input forms from the schema. It runs either hosted by Sanity, as at LeanWave, or on your own domain. Because the Studio is code, every field can be adapted: validation rules, preview cards, language switchers.

GROQ is the query language the website uses to fetch content. In plain words: "Give me all published articles in the comparison category, sorted by date, with title, slug and thumbnail." Astro runs that at build time and bakes the answer into HTML; Next.js runs it when the page is requested. Content lives in one place, and each page fetches exactly the fields it needs.

Webhooks close the loop. When your marketing team saves a change, Sanity calls the hosting (Vercel in our case) and the website rebuilds. One detail from practice: the webhook needs a rule for which events trigger it. Without it Sanity shows the hook as active, and it never fires.

Presentation Mode: your marketing team edits text in the live preview

The most common objection to a website built in code is "then my team cannot change anything themselves." Presentation Mode is the answer.

Inside the Studio the real website runs as a preview. Hover over a headline and a frame appears. Click into it and the matching field opens on the right, and the preview updates as you type. No guessing which field controls "hero subline".

Technically this works through Stega, and the idea is simpler than the name suggests: in the preview, Sanity hides invisible characters in every text that say which document and field the text comes from. The browser does not display them, the overlay reads them and knows on click which field to open. The public website does not contain these characters; they exist only in the preview build.

The Webflow Editor has offered click-on-text editing for years, for Webflow websites. Presentation Mode brings the same feeling to a website built in code and separates content from layout: your marketing team cannot move a spacing or delete a section, because the layout lives in code.

At LeanWave the preview runs as its own deployment on Vercel. The public website is built statically, without React and without overlays. The preview deployment builds from the same repository, renders on the server, shows drafts and delivers the overlays. It is permanently set to noindex so Google never finds a copy.

What Sanity does day to day for B2B

Five points that regularly make the difference in a project, from the first language switch to sign-off.

Localization without a per-language fee

Sanity has no language add-ons. At LeanWave, translation runs through the official Document Internationalization plugin: every document has a language field, the German variant carries the ID of the English document plus "-de", and the language switcher sits at the top of the document. English lives at the root, German under /de. URL segments are translated, not just prefixed: /solutions is /de/loesungen. hreflang is output reciprocally including x-default. If a translation is missing, the language switcher stays on the current language instead of leading to a 404. In Webflow every language costs 9 to 29 $ per month extra, as the Webflow vs. Next.js comparison shows.

References between documents

A testimonial on five pages exists once and is referenced five times. If the customer changes their job title, you change it in one place. At LeanWave the FAQ section of the home page is a reference list: it does not show every FAQ document automatically, only the ones someone deliberately pulls in. That is intentional, but you need to know it: a new FAQ only shows up once it is on the list.

Image pipeline

You upload images once at full size. Sanity's image CDN delivers size and format per request. The frontend requests width, crop, and a modern image format, and nobody converts source files by hand. Your marketing team sets hotspot and crop in the Studio.

Roles and seats

20 seats on the free plan means 20 people with a login. Roles such as Administrator, Editor and Viewer are predefined, which covers editors, agency and approver. Custom-defined roles only appear on the higher plans.

Drafts and versions

Every change lands as a draft first. Publishing is one click, and only then does the webhook fire. The history can be viewed and restored; how far back it reaches depends on the plan. One editor prepares, one person in charge publishes, and nobody sends text back and forth by email.

Sanity and AI content systems

Everything in Sanity is structured and reachable through the API. An article is not a block of text but a document with title, intro, sections, FAQ and tables as separate fields. That is exactly what AI agents need.

Sanity provides the API and an official MCP server (Model Context Protocol, a standard interface through which AI assistants such as Claude or ChatGPT use tools). An agent can read documents, create drafts and set references. With a website built in code, the whole chain becomes programmable: content model, page templates, content, internal linking, schema markup, sitemap and deploy.

To place the advantage correctly: Webflow and Wix have official MCP servers and APIs too, so an agent can work there as well. Sanity's difference is not the access but what sits behind it: a content model you define yourself, without a builder's item or collection ceiling, templates that may combine several document types, and a frontend in code where rendering, caching, schema, sitemap, and internal linking all work off the same data.

From structured data you get hundreds or thousands of pages from one template: industries times services times cities, glossaries, comparison pages. One warning from our own experience: Google demotes such pages as doorway pages as soon as they lack real substance per page. A template with a swapped city name is not enough. How AI search engines read such content is covered in the article on Generative Engine Optimization.

Sanity vs. Contentful vs. Storyblok vs. Webflow CMS

Sanity hands the editor to the developer as code, Contentful ships a finished editor with fixed field types, Storyblok builds on a visual editor with component blocks. Webflow CMS is primarily tied to the Webflow editor, though it can be used headless through the API. It belongs in the table because for many B2B companies it is the alternative actually on the table.

For the decision between the three headless systems one criterion outweighs the others for us: who owns the editor. With Sanity the Studio is part of your repository. The underlying question is covered in Headless CMS explained.

What Sanity costs

Prices are from sanity.io/pricing as of September 13, 2026, in US dollars.

Free: 0 $. 20 seats, 10,000 documents, 100 GB of assets, 100 GB of bandwidth per month. Presentation Mode and visual editing are included. Growth: 15 $ per seat per month, 25,000 documents. Enterprise: custom.

What the limits mean: in-sync.io, with 49 knowledge articles, 10 service pages, 17 city pages, case studies, FAQs and team entries, uses a fraction of 10,000 documents. LeanWave sits at 64. 10,000 documents are enough for most company websites. It gets tight only with programmatic systems of several thousand combinations of industries, cities and services, and then Growth is the next step.

The 100 GB of bandwidth cover image delivery through the Sanity CDN. A B2B website with a few thousand visitors a month stays comfortably inside the free plan.

Add hosting: Vercel Pro costs 20 $ per developer seat per month including 20 $ of usage credit, with no base fee per project. An Astro or Next.js website with Sanity Free typically runs at 0-20 $ hosting per month for a single company, against 25-54 $ for Webflow Premium with localization. What that means in the project budget is covered in web development cost.

Limits and drawbacks

The reasons against Sanity belong on the table before the contract.

The Studio has to be configured. After signing up it is empty. Every document type, every field is code. That is the strength and the effort a site builder does not require.

Sanity is not a design tool. Colors, spacing and layouts are set nowhere. The design is created in Figma and built as code. If you want to move layouts yourself, you need Webflow.

Schema changes need a developer. A new "price" field on the service page is a change to schema and frontend. New content within the existing model (a new article, a new city page) is something your marketing team creates on its own.

The dataset is publicly readable or needs a token. A public dataset keeps the build simple and is uncritical for content that is on the website anyway. As soon as a project keeps confidential content in the same dataset, it needs a private dataset and a token in the build. That decision belongs at the start of a project, not at the end.

GROQ has a learning curve for developers. The query language differs from SQL and GraphQL. A team without Sanity experience needs onboarding time.

Two systems instead of one. Studio and website are separate deployments. The webhook must run, the preview deployment must stay noindex, and on static websites a change goes live only after the rebuild.

When Sanity, when not

Sanity is not a universal tool. These two lists are the short version of how we decide in a project.

Choose Sanity if …

One point that holds long term is enough.

Choose something else if …

Here too, one point is enough to tip the decision.

How we use Sanity

in-sync.io. Our website ran on Wix until 2026 and has run on Next.js, Sanity and Vercel since June 2026. 49 knowledge articles, 10 service pages and 17 city pages come from Sanity, each in DE and EN with hreflang. Articles are assembled from typed blocks (section, table, FAQ, callout, CTA and more) rather than one free text field. A new city page therefore means one document in the Studio, no line of code. Server rendering, llms.txt, IndexNow and FAQPage schema live in code. The old Wix website ranked for practically nothing; the new one has been building its rankings since June.

LeanWave (Otto ID Solutions). RFID solutions for textile services and laundries, leanwave.com. Astro static, Sanity, Tailwind, Vercel. 64 documents, 86 image assets, bilingual EN/DE via Document Internationalization, translated URL segments, Presentation Mode through a separate preview deployment, rebuild via webhook on every change. In numbers: leanwave.com, which we build statically with Astro, loads about 39 KB of JavaScript in three files on its home page. One of our Webflow sites loads about 740 KB in thirteen files at the same place (our own measurement, 13 September 2026). More on the framework choice in the hub article on site builders, Webflow or Next.js.

Ullsteinhaus and Monteval. Both run on Astro and Sanity, Ullsteinhaus with React and Three.js for 3D elements, Monteval with GSAP animations. The same content database, two completely different frontends.

Coming from Webflow or WordPress, migrating Webflow to Next.js describes the export path through to the Sanity import. A move without losing rankings follows our process from website relaunch without SEO loss, delivered through our relaunch agency. A new website on Astro or Next.js with Sanity is built by our web development agency.

Frequently asked questions

Next step

Does Sanity fit your website? In a first call we tell you whether Sanity, Webflow or something else is the right base.