DEV Community: Nayan Kyada

Sanity vs WordPress Headless: Total Cost of Ownership in 2026

Nayan Kyada — Sun, 06 Sep 2026 08:45:54 +0000

Choosing between Sanity and headless WordPress is not just a technical decision — it is a budget decision that compounds over three to five years. This post puts real numbers next to both stacks so you can see where costs accumulate, not just what the hosting invoice says on day one.

Why TCO matters more than the monthly bill

Most cost comparisons stop at the SaaS subscription or the VPS price. That ignores developer time, plugin licensing, incident response, and the performance work that eventually lands on a dev's plate when the site starts failing Core Web Vitals. Sanity and WordPress headless have wildly different cost profiles once you account for all of those.

Stack assumptions

For a fair comparison I am using a mid-size marketing site: 10–50 content types, 5–15 editors, a team of 1–3 developers, hosted on Vercel (Sanity side) or a managed host like Kinsta or WP Engine (WordPress side).

Sanity + Next.js stack:

Sanity Growth plan (the realistic paid tier for a real team)
Vercel Pro
Sanity Studio hosted in the same Next.js repo
Next.js App Router with ISR

Headless WordPress stack:

WordPress on Kinsta or WP Engine Business plan
WPGraphQL or REST API
Next.js App Router frontend on Vercel Pro
ACF Pro for custom fields
Yoast SEO premium

Year 1 cost comparison

Line item	Sanity + Next.js	Headless WordPress
CMS hosting / SaaS	$249/mo (Sanity Growth)	$115–$200/mo (Kinsta Business)
Frontend hosting	$20/mo (Vercel Pro)	$20/mo (Vercel Pro)
Plugin / addon licenses	$0	$89/yr ACF Pro + $99/yr Yoast = ~$16/mo
CDN / image delivery	Included in Sanity	Included via host or ~$10–$20/mo extra
Initial dev setup (hours)	40–60 hrs	60–90 hrs
Monthly total (SaaS only)	~$269/mo	~$151–$236/mo
Annual SaaS spend	~$3,228	~$1,812–$2,832

At first glance WordPress headless looks cheaper. It usually is in year one, especially if you already have a WordPress developer on staff.

Where the curve flips

Plugin maintenance and security patches

Headless WordPress still runs the full WordPress engine. You still apply core updates, plugin updates, and ACF updates. A plugin conflict or a security patch gone wrong on a WPGraphQL version can break the entire data layer for your Next.js frontend. Someone has to own that maintenance window. Budget 2–4 hours per month for a developer at $80–$150/hr and the gap closes fast.

Sanity has no plugin layer on the data side. You update your Studio npm package in your repo like any other dependency. Breaking changes are rare and migration guides exist.

Query complexity and developer time

WPGraphQL is capable but verbose for complex nested content. Filtering by taxonomy, fetching related posts with authors, and handling custom field groups all require careful query construction and often hit the default query depth limit. Teams regularly spend time tuning WPGraphQL settings and working around limitations that do not exist in GROQ.

A typical join in GROQ:

// sanity/queries/post.ts
*[_type == "post" && defined(slug.current)] {
  title,
  slug,
  publishedAt,
  "author": author->{ name, image },
  "categories": categories[]->{ title, slug }
}

The equivalent WPGraphQL query is longer, requires knowing the exact connection node structure, and breaks if your ACF field group is attached incorrectly. This is not a dealbreaker but it adds hours when things go wrong.

Image delivery and Core Web Vitals

This is the biggest hidden cost on the WordPress side. WordPress stores originals. WPGraphQL returns the source URL. Getting auto-format WebP, responsive sizes, and a stable aspect ratio into next/image requires either the Jetpack CDN, Cloudinary, or a separate image pipeline. None of those are free and all of them require dev time to wire up correctly.

Sanity's image pipeline is baked in. You pass ?auto=format&w=800&fit=crop via @sanity/image-url and the CDN handles format negotiation, resizing, and caching. LCP and CLS fixes that take a week on WordPress headless take a day on Sanity.

// lib/sanity/image.ts
import imageUrlBuilder from '@sanity/image-url'
import { client } from './client'

const builder = imageUrlBuilder(client)

export function urlFor(source: SanityImageSource) {
  return builder.image(source).auto('format').fit('crop')
}

Scaling and API limits

Sanity Growth includes 500k API requests/mo and 1M CDN requests/mo. Most marketing sites never touch those limits. If you do, overages are $0.35 per 100k additional API requests — not cheap, but predictable.

Kinsta Business gives you 200k monthly visits. Spike past that and you get an invoice for overage traffic. For a site that gets a burst from a PR hit, this can be a surprise $50–$200 charge. WP Engine charges similarly.

3-year TCO estimate

	Sanity + Next.js	Headless WordPress
SaaS / hosting (3 yr)	~$9,684	~$6,000–$9,000
Plugin licenses (3 yr)	$0	~$600
Dev maintenance est. (3 yr)	~$3,600 (5 hrs/mo × $60 blended)	~$7,200 (10 hrs/mo × $60 blended)
Image pipeline setup	$0 (built-in)	$500–$1,500 one-time
Total 3-year TCO	~$13,284	~$14,300–$18,300

The Sanity stack costs more on the SaaS line but less in aggregate because the maintenance burden is lower and the image and query tooling is included.

When headless WordPress still wins

Your existing content is in WordPress and migration cost (time + risk) is not justified
Your team already owns WordPress deeply and Sanity is a new skill to hire or train
You are under $500/mo budget and can accept higher maintenance overhead
You need WooCommerce in the same codebase

When Sanity is the clear choice

Greenfield project with no WordPress debt
Team cares about Core Web Vitals and does not want to build a separate image pipeline
Editors need real-time preview, document versioning, or portable text flexibility
You want typed GROQ queries via Sanity TypeGen and do not want to hand-maintain a GraphQL schema

The TCO numbers above are estimates based on publicly available pricing as of September 2026 and typical hourly rates for mid-market freelance developers. Your actual numbers will vary depending on team seniority, content complexity, and traffic patterns — but the direction of the curve is consistent across the projects I have worked on.

Bunny Stream Pricing 2026: Free Trial Limits, Storage Costs & When to Upgrade

Nayan Kyada — Sat, 05 Sep 2026 08:27:57 +0000

Bunny Stream doesn't have a free tier in the traditional sense — it has a pay-as-you-go model with a $1 trial credit, which catches a lot of developers off guard when they're budgeting for a Sanity + Next.js video stack. If you're evaluating Bunny Stream against Mux or Cloudinary Video for a content site, this is the cost breakdown you actually need.

How Bunny Stream pricing works

Bunny Stream charges on two axes: storage and bandwidth (egress). There's no monthly seat fee and no document limit — just consumption. That makes it attractive for high-traffic sites with predictable video inventories, and awkward for projects that need per-user signed streams or adaptive bitrate with DRM.

Here are the published rates as of September 2026:

Item	Price
Storage	$0.005 / GB / month
Bandwidth (EU/US)	$0.01 / GB
Bandwidth (Asia/Oceania)	$0.03 / GB
Bandwidth (South America)	$0.045 / GB
Encoding (720p)	$0.006 / minute of source
Encoding (1080p)	$0.012 / minute of source
Encoding (4K)	$0.036 / minute of source
Trial credit	$1.00 (no card required to start)

The trial credit runs out fast. A single 10-minute 1080p video encodes to roughly $0.12 and sits at around 800 MB after encoding — another $0.004/month in storage. Serve that file to 1,000 viewers watching half of it (5 minutes × average 360p–720p = ~150 MB delivered) and you're at roughly $1.50 in bandwidth. The $1 trial is gone in one real test.

What triggers an upgrade from the trial

Bunny Stream has no free ongoing tier. After the $1 credit, you're billed monthly based on usage. There's no threshold that unlocks features — encoding quality, API access, and HLS delivery are available from day one. The upgrade trigger is simply burning through the credit.

What changes as you scale:

Volume discounts kick in automatically at 100 TB/month bandwidth (negotiated rates).
Bunny CDN pull zones can be configured separately, which adds complexity but cuts costs for very high-traffic regions.
Dedicated storage replicas are a paid add-on if you need geographic redundancy beyond their default setup.

For a typical Sanity + Next.js marketing site with 20–50 embedded videos, monthly spend lands in the $15–$40 range — mostly bandwidth-driven by your traffic geography.

Bunny Stream vs Mux vs Cloudinary: honest cost comparison

This is the comparison that actually matters for a Next.js video stack. All three integrate with Sanity and deliver HLS, but pricing models differ enough to change the decision depending on your use case.

	Bunny Stream	Mux	Cloudinary Video
Free tier	$1 trial only	10,000 encoding minutes/month free	25 GB storage + 25 GB bandwidth free
Storage cost	$0.005/GB/month	$0.006/GB/month	Included in quota
Bandwidth cost	$0.01–$0.045/GB	$0.0025–$0.01/GB	$0.02/GB after quota
Encoding cost	$0.006–$0.036/min	$0.015/min (720p input)	Per transformation
Signed URLs / DRM	No native DRM	Yes (Token Auth)	Yes
Per-viewer data	No	Yes (Mux Data)	No
Sanity plugin	Community	Official	Official

Mux wins on analytics and DRM. Cloudinary wins if you're already using it for images and want a single vendor. Bunny Stream wins on raw bandwidth cost for EU/US traffic — $0.01/GB versus Mux's $0.0025 sounds close until you realise Mux's free 10,000 minutes absorbs most small-to-medium catalogs.

When Bunny Stream makes sense

Bunny Stream earns its place in a few specific situations:

High-volume EU/US traffic, static catalog. If you have 500+ videos that don't change often and your audience is in Europe or North America, Bunny's storage + bandwidth math beats Mux for pure cost. No per-minute encoding overhead on existing assets.

No need for analytics or DRM. If you're embedding public marketing videos and don't need per-viewer playback data or signed stream protection, you're paying for capabilities you don't need with Mux.

Already using BunnyCDN. If your CDN is Bunny, consolidating video there cuts the operational surface and gives you a unified billing dashboard.

When to skip it

Don't use Bunny Stream if:

You need signed HLS for gated content. Bunny doesn't support token-based playback protection without routing through their CDN pullzone with signed URL hacks — it's messy.
You're building a Sanity + Mux setup and want the official plugin and typed webhook payloads. The Mux Sanity plugin is maintained and gives you asset state management out of the box.
Your audience is primarily in South America or Southeast Asia. At $0.045/GB, Bunny's regional bandwidth is expensive — Cloudinary or a self-hosted solution on a regional CDN is cheaper.

Realistic monthly cost at different scales

Site profile	Videos	Monthly views	Est. Bunny cost
Small marketing site	10	2,000	~$4–$8
Mid-size blog	50	20,000	~$25–$50
Course platform (public)	200	100,000	~$150–$300
Media/news site	1,000	500,000	~$600–$1,200

At the course platform level, Mux's per-viewer data and DRM justify the premium. Below that, Bunny is genuinely competitive if you can live without analytics.

The short version

Bunny Stream is the right call when you want cheap, fast public video delivery in EU/US and you don't need DRM, per-viewer data, or an official Sanity plugin. The $1 trial is mostly symbolic — budget from day one as a pay-as-you-go service. For anything requiring signed playback or detailed analytics, Mux is worth the premium. For teams already on Cloudinary for image delivery, adding video to the same account simplifies billing and keeps transformation logic in one place.

Sanity vs Kontent.ai for Next.js in 2026: An Honest Comparison

Nayan Kyada — Fri, 04 Sep 2026 08:57:10 +0000

Sanity and Kontent.ai both target content-driven teams who want a hosted, API-first CMS — but they make very different bets about who owns the content model, how queries are written, and what happens when the project scales. If you're scoping a Next.js site in 2026 and these two are on your shortlist, here's the honest side-by-side.

What each CMS actually is

Sanity is a document-based CMS with a flexible, code-first schema system. You define document types in TypeScript files inside your repo, run sanity deploy to push the Studio, and query content with GROQ — a purpose-built query language that supports joins, coalesce, conditional projections, and reference flattening in a single round trip. The real-time content lake means every query is live against a single global dataset with no additional cache layer you need to manage.

Kontent.ai (formerly Kentico Kontent) is a structured, modular content platform. Schemas are defined inside the Kontent.ai web UI, not in code. Content is fetched via REST or GraphQL endpoints, and the platform leans heavily on content types and linked items rather than Sanity's reference system. It positions itself at enterprise marketing teams — multi-environment workflows, content branching, and deep governance are first-class concerns.

Schema and content modelling

Sanity's schema lives in your codebase. A blog post type looks like a TypeScript object you version-control and deploy alongside the rest of the app. Field-level validation, custom input components, and document actions are all code you write and own. The tradeoff: a new developer has to read the schema files to understand the content model, and accidental schema drift between Studio versions is a real production risk if you don't lock Studio and API versions.

Kontent.ai models content through a UI-driven environment system. You promote content models from development to staging to production through environment cloning, not code. This is genuinely useful for teams where a content strategist — not a developer — owns the content model. The downside is that schema-as-code advocates will find the round-trip (UI change → API test → code change) slower than Sanity's single-PR workflow.

GROQ vs REST and GraphQL

GROQ is Sanity's clearest differentiator. A single GROQ query can join a post to its author, coalesce a localized field with a fallback, flatten a nested array, and return only the fields the page actually needs — without multiple API calls or a custom resolver layer. For Next.js App Router sites using React Server Components, this means you write one query per route, pass the typed result straight to a component, and never touch a loading spinner for server-rendered content.

Kontent.ai's Delivery API is REST-first with a GraphQL variant available on higher plans. For simple content fetches it works fine, but joining linked items requires either multiple requests or the use of depth parameters that pull more data than you need. The GraphQL API solves this more elegantly, but you need to be on a Business or Enterprise plan to use it without restrictions.

// Sanity: one query fetches post + author + category, returns only what the RSC needs
*[_type == "post" && slug.current == $slug][0] {
  title,
  publishedAt,
  "slug": slug.current,
  "author": author->{ name, "avatar": image.asset->url },
  "category": category->{ title },
  body
}

There is no equivalent single-query pattern in Kontent.ai's REST API without fetching linked items separately or relying on the depth parameter.

Next.js integration

Sanity ships a first-party Next.js toolkit (next-sanity) that covers the Presentation layer (live preview inside the Studio), draft mode, sanityFetch with built-in revalidation tags, and Sanity TypeGen for end-to-end typed GROQ results. Setup is about 30 minutes for a fresh App Router project.

Kontent.ai has an official JavaScript SDK and a Next.js starter, but there is no equivalent of the Presentation layer or a first-party ISR integration. Revalidation is handled via webhooks you wire up yourself to Next.js route handlers — the same pattern, but without the opinionated glue Sanity provides. For teams that already have a webhook infrastructure this is fine; for teams starting fresh, Sanity's out-of-the-box ISR story is noticeably smoother.

Pricing side-by-side

Factor	Sanity	Kontent.ai
Free tier	2 users, 3 datasets, 10 GB bandwidth, 20 GB assets	3 environments, 5 users, 2 million API calls/month
First paid tier	Growth ~$99/mo (5 users, 100 GB BW)	Business ~$1,250/mo (20 users, GraphQL, branching)
Per-seat pricing	No — flat plan tiers	Yes — adds cost as team grows
Bandwidth overage	$1/GB above plan limit	Included up to plan limit, then negotiated
Self-hosting	Studio only (OSS), content lake is hosted	Not available
GraphQL	GROQ only (no GraphQL)	REST free; GraphQL on Business+

The pricing cliff is steep on Kontent.ai. Moving from the free tier to Business jumps to ~$1,250/month — a hard number for most indie teams or small agencies. Sanity's Growth plan at ~$99/month is a more forgiving step. For enterprise teams already buying Kontent.ai inside a Kentico contract, the calculus is different, but for greenfield Next.js projects, Sanity's pricing curve fits better.

When Kontent.ai wins

Kontent.ai makes sense when the buyer is a mid-to-large enterprise that already uses Kentico products, needs formal content governance with environment promotion workflows, has a dedicated content strategist who owns the model (and shouldn't be touching code), or requires multi-brand content reuse across separate front-ends managed through a single hub. The enterprise support tier and SLA commitments are also stronger out of the box.

When Sanity wins

Sanity is the better pick for developer-led teams building on Next.js App Router where schema-as-code matters, query performance matters, and the content model evolves alongside the product. The GROQ + TypeGen + next-sanity stack removes a full category of integration boilerplate. For freelancers and small agencies shipping fast, Sanity's free tier covers most projects in production, and the Growth tier is affordable long before Kontent.ai's Business plan becomes relevant.

The honest verdict

For most Next.js projects in 2026, Sanity is the default choice — better query ergonomics, better Next.js integration, and a pricing model that scales proportionally. Kontent.ai earns its place when enterprise governance and formal content workflows are requirements, not nice-to-haves. If your client asks for environment branching and content approval chains on day one, Kontent.ai is worth the price. If they ask for a fast, editor-friendly CMS that developers can maintain in a PR, Sanity wins.

Sanity vs Payload CMS vs Strapi: Pricing Comparison 2026

Nayan Kyada — Thu, 03 Sep 2026 09:03:54 +0000

Sanity, Payload CMS, and Strapi are the three headless CMS options that come up most often when a Next.js team is scoping a new project in 2026. Each has a free tier, each can power a production site, and each will cost you something different once you cross a threshold. This post puts the pricing side by side so you can see where the bills actually start.

Why pricing for these three is hard to compare directly

The billing models are structurally different. Sanity charges on hosted infrastructure — API requests, bandwidth, and seats. Payload charges nothing for the software itself; you pay for wherever you host it. Strapi has both a self-hosted open-source edition and a managed cloud product. That means a like-for-like comparison requires you to pick a deployment scenario for each, not just copy numbers from a pricing page.

I'm going to compare three scenarios that actually come up on client projects:

Solo developer or small startup — one editor, moderate traffic, no dedicated DevOps.
Small agency or product team — three to five editors, high-traffic content site, staging + production.
Growing company — ten-plus editors, multiple projects, compliance requirements starting to matter.

Side-by-side pricing table

	Sanity	Payload CMS	Strapi
Free tier	Free plan: 2 users, 10k API CDN requests/mo, 10 GB bandwidth, 20 GB assets	MIT licence, self-host for free, unlimited	Community edition: self-host for free, unlimited
Paid starts at	Growth: $15/mo (per project)	No SaaS — you pay hosting only	Cloud Starter: $29/mo (1 project, 1 env)
Per-seat cost	$10/user/mo above 2 seats (Growth)	$0 (self-host) or $0 (Payload Cloud, included in project price)	$9–$29/user/mo on Cloud; free on self-hosted
API request limits	500k CDN req/mo on Growth; overages ~$0.50 per 10k	None (your own infra)	None on self-hosted; fair-use on Cloud
Bandwidth	1 TB/mo on Growth; $0.18/GB overage	Your hosting provider's limit	Self-hosted: your provider; Cloud: unmetered on paid plans
Staging environment	Separate project = separate billing	Free (just spin another instance)	Cloud: $29/mo per additional environment
Enterprise / custom	Custom pricing, SSO, audit logs	Self-host at any scale; Payload Cloud Enterprise: contact	Strapi Enterprise: custom, starts ~$1,800/mo

Scenario 1: solo developer, small project

Sanity's free plan is genuinely usable here. Two users and 10k CDN requests per month is tight for a busy site, but fine for an early-stage product or portfolio. The real limit is bandwidth: 10 GB goes fast if you're serving unoptimised images directly from the CDN rather than using @sanity/image-url with format and size parameters.

Payload on a $5–10/mo VPS (Fly.io, Railway, or a small DigitalOcean droplet) is cheaper in raw dollar terms — essentially free software plus a few dollars of compute. The trade-off is you're now responsible for uptime, backups, and upgrades. For a solo developer comfortable with that, Payload wins on cost at this tier.

Strapi Community Edition on the same $5–10 VPS gives you the same equation. Strapi Cloud's Starter plan at $29/mo is more than either of the above, so most solo devs skip it.

Winner at this tier: Payload or Strapi self-hosted (near-zero licence cost). Sanity free plan is competitive if you want zero infrastructure work.

Scenario 2: small team, production + staging

This is where the pricing gap opens up.

Sanity Growth at $15/mo per project means $30/mo for production and staging as two separate projects (Sanity doesn't have native environments — a common source of confusion). Add three editors above the included seats: $10/user × 1 extra = $10/mo. Realistic total: $40–50/mo, not counting asset bandwidth overages.

Payload self-hosted on a $20–40/mo managed Postgres instance (Railway or Neon) plus a small compute node: roughly $25–45/mo total. Payload Cloud is in beta/early GA at the time of writing — pricing is per-project and has been competitive, but check the current rates before committing. Backup strategy is your responsibility.

Strapi Cloud's Pro plan at $99/mo includes three environments and five users. That's genuinely easier than self-hosting, but it's meaningfully more expensive than either Sanity or Payload at this scale. Self-hosted Strapi with a managed Postgres: $25–45/mo, similar to Payload.

Winner at this tier: Payload self-hosted if your team has DevOps comfort. Sanity Growth if you want a managed platform without surprising bills. Strapi Cloud is convenient but overpriced relative to the alternatives until you're closer to the Enterprise tier.

Scenario 3: ten-plus editors, growing company

Sanity's per-seat cost compounds. Ten editors on Growth: 8 additional seats × $10 = $80/mo in seats alone, plus the $15 base, plus likely multiple projects. A five-project team pays $15 × 5 = $75/mo in project fees. Realistically $150–300/mo before you hit Enterprise conversations.

Payload at this scale is still just infrastructure cost. Ten editors change nothing about the licence. A production-grade setup on Railway or AWS with managed Postgres, Redis for jobs, and a CDN in front: $80–150/mo depending on traffic. No per-seat tax.

Strapi Enterprise starts around $1,800/mo and is aimed at companies needing SSO, audit logs, and SLAs. That's a significant jump. Self-hosted Strapi with ten editors: still just infra cost, same as Payload.

Winner at this tier: Payload or Strapi self-hosted on raw cost. Sanity becomes worth the premium if the managed hosted experience, real-time collaboration, and CDN asset pipeline save engineering time that would otherwise go to infra maintenance.

What actually triggers an upgrade on each platform

Sanity: Exceeding 2 users, hitting the 10k CDN request cap, or needing more than 10 GB asset storage. Most sites hit the request cap first.
Payload: Nothing triggers an upgrade in the licence sense. You upgrade your hosting when you need more CPU, memory, or Postgres connections.
Strapi: On Cloud, needing a staging environment ($29/mo per additional env) or more than the included seats. On self-hosted, nothing — until you need Enterprise features.

The real cost question

Payload and Strapi self-hosted are cheaper in licence terms, sometimes dramatically so. But they're not free. Someone has to handle database backups, version upgrades, and on-call when the server runs out of disk space at 2 AM. For a team with a dedicated engineer, that cost is negligible. For a founder who just wants the CMS to work, Sanity's managed hosting is often worth the seat fees.

If I'm building a client project where the client will manage the CMS long-term without a developer on retainer, Sanity's hosted model reduces operational risk enough to justify the cost over self-hosted Payload or Strapi. If I'm building something for a technical team that already runs managed infrastructure, Payload on Railway is hard to beat on total cost of ownership.

Sanity vs Keystatic for Next.js in 2026: An Honest Comparison

Nayan Kyada — Wed, 02 Sep 2026 08:54:17 +0000

Sanity and Keystatic both pitch themselves as great fits for Next.js content sites, but they come from completely different philosophies. Sanity is a hosted API-first CMS with a cloud database and a configurable Studio; Keystatic stores content as files in your Git repo and runs the editor UI locally or on a lightweight cloud adapter. Choosing between them has real consequences for your architecture, your editor team, and your monthly bill.

What Sanity vs Keystatic actually are

Sanity runs your content in a managed cloud dataset. Every document is stored in Sanity's infrastructure, fetched over GROQ via CDN-backed APIs, and served through @sanity/client or the Content Lake REST API. The Studio (sanity.io/studio) is a React app you deploy anywhere — Vercel, your own domain, or embedded in your Next.js project under /studio.

Keystatic is a local-first CMS. Content lives in .yaml, .json, or MDX files inside your repository. The editor UI (/keystatic) is a Next.js route handler that mounts into your existing app. On Keystatic Cloud (their hosted offering), you get GitHub OAuth and a remote editing UI without needing to run everything locally. No separate database, no separate API — just files on disk that your Next.js app reads at build time or via the filesystem at runtime.

Editor experience

Sanity's Studio is mature and highly configurable. Document-level previews, portable text with custom components, image hotspot, scheduled publishing, roles and permissions, and AI Assist are all first-class. Editors get a purpose-built content interface that feels like a product.

Keystatic's editor is simpler by design. It handles structured fields (text, number, select, relationship between collections) and rich text via Markdoc or MDX. It's fast to configure and works well for developer-managed blogs and docs sites. What it doesn't have yet: image hotspot, document-level live preview in the Sanity sense, fine-grained RBAC, or anything resembling Sanity's workflow tooling.

If your editors are non-technical marketers who need drafts, scheduling, and structured rich content, Sanity wins. If your editors are developers or technical writers comfortable with files and GitHub PRs, Keystatic is significantly less friction to set up.

Querying content in Next.js

Sanity uses GROQ, a purpose-built query language that handles joins, conditional projections, and array operations with one round-trip:

// Fetch post with author name and first category label — one query, no N+1
*[_type == "post" && slug.current == $slug][0] {
  title,
  "author": author->{ name, image },
  "category": categories[0]->title,
  body
}

Keystatic uses its reader API, which resolves content directly from the filesystem. In a Next.js App Router page it looks like this:

// app/blog/[slug]/page.tsx
import { createReader } from '@keystatic/core/reader';
import keystaticConfig from '../../../keystatic.config';

const reader = createReader(process.cwd(), keystaticConfig);

export default async function PostPage({ params }: { params: { slug: string } }) {
  const post = await reader.collections.posts.read(params.slug);
  if (!post) return notFound();
  // post.title, post.content(), etc.
}

The Keystatic reader has zero network latency — it reads files. But it has no cross-collection join API. If you need related posts or author lookups, you're writing that logic yourself. For simple content structures it's elegant; for complex editorial graphs it gets messy fast.

Performance and caching

Sanity fetches over HTTPS with CDN caching. With Next.js App Router you control revalidation via next: { revalidate: 60 } on the fetch, or use tag-based revalidation with webhooks. LCP on image-heavy pages is mainly a function of Sanity's image CDN speed and how you configure next/image — both of which you control.

Keystatic content is already on disk at build time. Static rendering is trivially fast. The trade-off is that content updates require a Git push and a redeploy, or you configure Keystatic Cloud with GitHub-backed storage to get a quasi-CMS feel without a full redeploy. Even then, updates in production depend on either ISR or a new build.

Pricing gap

Factor	Sanity	Keystatic
Free tier	2 non-admin users, 10k API req/day, 20 GB bandwidth	Fully free; open source (MIT)
Paid (entry)	Growth: ~$15/mo per seat	Keystatic Cloud: free beta (pricing TBD)
Storage model	Sanity-hosted dataset	Git repo / your own storage
Bandwidth costs	Included up to tier limit	Vercel / host bandwidth
Self-hosting	Studio only; Content Lake is always hosted	Fully self-hostable (files are just files)

Keystatic has a significant cost advantage for small teams. If you're running a personal blog, docs site, or a startup with developer editors, Keystatic is free to run indefinitely. Sanity's free tier is generous but its API request cap (10k/day) can be hit on a busy site without careful CDN caching.

For anything with non-developer editors, scheduled publishing, RBAC, or preview functionality that needs to rival Sanity Studio, the free tier disappears quickly and you're looking at $15–$30/seat/month on Sanity Growth.

When to use Sanity

You have non-technical editors who need a polished UI
Content relationships are complex (authors, categories, related content)
You need document-level scheduling, draft workflows, or RBAC
Image hotspot and cropping matter for your design system
You're building a multi-locale site with Sanity's i18n plugin

When to use Keystatic

You or your editors are comfortable with GitHub
Content is document-centric (blog posts, changelogs, docs) with simple schemas
You want zero external API dependency at build time
You're on a tight budget or building a side project
You want MDX authoring without a custom portable-text renderer

The honest verdict

Keystatic is excellent for what it is: a Git-backed CMS for developer-managed content. It ships fast, costs nothing, and integrates into a Next.js app without a separate service. But it's not trying to replace Sanity for teams with real editorial workflows.

Sanity's Content Lake, GROQ, and Studio are meaningfully more powerful for anything beyond a personal blog. You pay for that — in setup complexity, in per-seat pricing, and in API quota management. If your project needs what Sanity provides, the cost is justified. If it doesn't, Keystatic removes an entire external dependency from your stack.

Sanity vs Storyblok vs Contentful: Total Cost of Ownership in 2026

Nayan Kyada — Tue, 01 Sep 2026 09:31:29 +0000

When your Next.js project outgrows a free tier, the sticker price of a headless CMS is rarely the number that matters — the total cost of ownership is. Sanity, Storyblok, and Contentful each price differently enough that a team of five editors can pay anywhere from $99 to $2,000+ per month for functionally similar setups. This post puts concrete numbers on all three.

Why TCO beats list price

All three platforms have published pricing pages. None of them tell the full story. Contentful charges per locale. Storyblok charges per seat. Sanity charges per API request and non-cached bandwidth. The headline number you see on a pricing page is the floor — realistic bills add usage-based costs on top.

I'll walk through a consistent scenario: a marketing site with 5 editor seats, 3 locales, ~500 documents, moderate traffic (100k monthly pageviews via ISR), and a staging environment.

Sanity pricing in 2026

Sanity's free tier (the "Free" plan) gives you 2 datasets, 1 project, 10 non-admin users, 500k API requests/month, and 1 GB of assets. For solo developers or very small sites, that holds up fine.

The Growth plan is $99/month per project (as of mid-2026), which gets you:

Unlimited non-admin users (editors don't eat into seat costs)
3 datasets (dev, staging, production)
1M API requests/month included
20 GB bandwidth included
Overage: $0.001 per extra API request, ~$0.10/GB bandwidth

For the 5-editor, 3-locale scenario with ISR revalidation on every publish, you're typically inside the 1M request ceiling unless your site has aggressive polling. Real monthly bill: $99–$130.

The painful threshold is the Enterprise plan — there's no self-serve tier between Growth and Enterprise. If you need SSO, custom roles beyond the built-in ones, or an SLA, you're in sales territory. Anecdotally, Enterprise contracts start around $900–$1,200/month.

Plan	Price	Users	Datasets	API req/mo
Free	$0	10	2	500k
Growth	$99/project	Unlimited editors	3	1M
Enterprise	Custom	Unlimited	Unlimited	Custom

Storyblok pricing in 2026

Storyblok is per-seat, which makes cost grow linearly with team size. The Community plan is free for 1 user, 1 space, and 2 locales — barely useful for real projects.

The Entry plan is $99/month for 5 users and 1 space. Add the Extra Locales add-on for additional languages at $25/locale/month. Three locales on Entry: $99 + $25 = $124/month.

The Business plan is $449/month (5 included users, ~$19/additional user) and is where granular roles, custom workflows, and preview environments appear. If you need staging separated from production at the space level, you're paying $449 minimum.

Beyond that: Enterprise is custom-quoted, typically $1,500+/month for larger teams.

For the 5-editor, 3-locale baseline: you'd need the Entry plan plus locale add-ons, landing at $124/month. Sounds competitive — but add a dedicated staging space and you're suddenly in Business territory at $449/month.

Plan	Price	Users	Spaces	Locales
Community	$0	1	1	2
Entry	$99/mo	5	1	2 (+$25/extra)
Business	$449/mo	5 (+$19/extra)	3	5
Enterprise	Custom	Unlimited	Unlimited	Unlimited

Contentful pricing in 2026

Contentful's pricing is the most complex of the three. The Free tier gives 5 users, 2 locales, 25k records, and 48 publish actions/month — that publish ceiling alone disqualifies it for anything active.

The Basic plan is $300/month (per space), which is the cliff most teams hit after the free tier. You get 20 users, 15 locales, 50k records, and 2 environments. Three locales fall inside Basic.

Here's what makes Contentful expensive at scale: environments are the equivalent of Sanity datasets or Storyblok spaces, and you only get 2 on Basic. A proper dev/staging/production setup requires the Professional plan at $800/month per space. And if you add content previews, custom workflows, or content audit tools, those are add-on line items on top.

For the 5-editor, 3-locale baseline scenario: Basic covers it at $300/month. That's already 2–3x the cost of Sanity Growth or Storyblok Entry. Enterprise is $2,000+/month and requires a sales call.

Plan	Price	Users	Environments	Locales
Free	$0	5	2	2
Basic	$300/mo	20	2	15
Professional	$800/mo	20	9	27
Enterprise	Custom	Unlimited	Unlimited	Unlimited

Side-by-side for the 5-editor scenario

Platform	Monthly cost	Staging env	3 locales	Seat limits
Sanity Growth	~$99–130	Included (datasets)	Native	No seat cost
Storyblok Entry + locales	~$124	Extra space = $449 plan	$25/extra locale	5 users
Contentful Basic	$300	2 environments	Included	20 users

The table flips at scale. If you have 20+ editors, Sanity's per-project flat rate starts winning decisively. If you need deep visual editing and page-builder UX, Storyblok's tooling is genuinely superior and might justify the seat cost for content teams. If your organization already lives in Contentful's ecosystem and needs 27 locales, the Basic plan's locale ceiling matters more than the price.

What actually triggers an upgrade

Sanity: exceeding 1M API requests/month (common if you run on-demand ISR with many routes and rapid publishing), or needing SSO/SCIM for a corporate IT team.

Storyblok: adding a fourth editor (hitting the 5-user Entry ceiling), or needing a separate staging space — which requires jumping from $124 to $449/month overnight.

Contentful: the 48 publish actions/month free-tier cap is the first wall. The second is the 2-environment limit on Basic — any real CI/CD flow needs at least 3.

Which one fits which team

Sanity is the strongest pick for developer-led teams running Next.js with ISR or PPR, especially when editor count varies. The flat Growth pricing and GROQ flexibility reward teams that control their own data model.
Storyblok is worth the seat cost for marketing-heavy teams that need a visual editor and page-builder without developer involvement. The hidden cost is staging environments.
Contentful is the safe enterprise choice when procurement, SSO, and a recognizable vendor name matter more than price. The $300 Basic floor is difficult to justify for small teams.

Netlify Pricing 2026: Free Tier Limits, Build Minutes & When to Upgrade

Nayan Kyada — Mon, 31 Aug 2026 11:00:54 +0000

Netlify pricing confuses a lot of teams because the free tier looks generous until you hit one of its three real limits: build minutes, bandwidth, or serverless function invocations. This post breaks down what each Netlify plan actually includes in 2026, what triggers an upgrade, and how it stacks up against Vercel for a typical Next.js project.

What Netlify's free tier actually gives you

The Starter plan (free, one member) includes:

300 build minutes/month — the most common ceiling for active projects
100 GB bandwidth/month — generous for most content sites
125,000 serverless function invocations/month — fine for route handlers and ISR revalidation endpoints
1 concurrent build — means queued deploys when you push frequently
No background functions on free
No split testing or analytics
Community support only

Three hundred build minutes sounds like a lot. A typical Next.js + Sanity full build (no ISR, full static export) takes 2–4 minutes. At 4 minutes per deploy you're capped at roughly 75 deploys a month. If you're running preview deploys on every PR — which Netlify's branch deploys make easy — you'll burn through that budget faster than you expect. A team doing daily content deploys plus CI previews will likely hit the ceiling by week three.

Paid plan breakdown

Plan	Price	Build minutes	Bandwidth	Serverless invocations	Team members	Support
Starter	$0	300/mo	100 GB	125K/mo	1	Community
Pro	$19/mo per member	1,000/mo (pooled)	400 GB	500K/mo	Up to 3	Email
Business	$99/mo per member	1,500/mo (pooled)	600 GB	1M+/mo	Up to 5	Priority
Enterprise	Custom	Custom	Custom	Custom	Unlimited	SLA

Pro is priced per member, so a three-person team pays $57/month minimum. That's the first sticker shock. Vercel's Pro tier is $20/month per member with similar per-seat math, so the headline numbers are close — but the overage rates differ significantly.

Where costs actually spike

Build minutes overages are $7 per 500 additional minutes on Pro. That sounds small but compounds. A project running Storybook previews, Playwright tests, and full Next.js builds across feature branches can easily consume 3,000 minutes a month — a $35 overage on top of the base $57 for three seats.

Bandwidth overages are $0.55 per GB beyond the plan limit. For image-heavy marketing sites that serve unoptimised assets directly from Netlify rather than through Sanity's image CDN or a dedicated image service, this adds up. If you're serving 50 GB over the 400 GB Pro limit you're looking at an extra $27.50. The practical fix is routing all Sanity images through the Sanity CDN with auto=format rather than proxying them through Netlify functions — but that's a separate architecture decision.

Serverless function execution time is charged after 125K invocations on Starter and 500K on Pro — at $2 per 500K additional invocations. For ISR-heavy Next.js apps that revalidate via Sanity webhooks, this is manageable. For apps doing full server-side rendering on every route, you'll want to model your expected invocation volume before committing.

Large Media (Netlify's Git LFS-based image storage) adds complexity. It's free up to 1 GB storage and 5 GB bandwidth per month, then $20 per 50 GB storage and $20 per 100 GB bandwidth. Most teams on Next.js skip this entirely in favour of Sanity's CDN, which is the right call.

Netlify vs Vercel: where the pricing actually differs

Factor	Netlify Pro	Vercel Pro
Per-seat price	$19/member/mo	$20/member/mo
Build minutes included	1,000/mo (pooled)	6,000/mo (pooled)
Bandwidth included	400 GB	1 TB
Serverless function invocations	500K/mo	1M/mo
Edge functions	Included	Included
ISR / on-demand revalidation	Via Next.js plugin	Native
Overage (build minutes)	$7/500 min	$1/100 build-minutes ($5/500)

Vercel's Pro plan includes six times the build minutes for roughly the same per-seat price. For teams deploying Next.js specifically, Vercel's native ISR and on-demand revalidation support is also meaningfully more reliable — Netlify's Next.js Runtime handles most patterns but has lagged on PPR and some App Router edge cases in practice.

The gap narrows if you're running a non-Next.js frontend (Astro, SvelteKit, plain React) or you want Netlify's form handling, identity (auth), or split testing — those are genuinely useful features with no direct Vercel equivalent.

When upgrading to Netlify Pro is the right call

Upgrade when you hit any of these:

Multiple team members need deploy access — the Starter plan's single-member limit is a hard wall for any real team
You're regularly queuing builds — one concurrent build on Starter means deploys block each other; Pro gives three
You need branch deploys plus preview deploy URLs for client review — technically possible on free, but you'll burn minutes quickly
You need email support with a response SLA — community-only on free is a real risk for client production sites

When to skip Netlify entirely

For Next.js projects built with App Router, ISR, and Sanity CMS, Vercel remains the lower-friction deployment platform. The build-minutes advantage on Vercel Pro is significant for teams running preview deploys, and native ISR revalidation means fewer workarounds. Netlify is a reasonable choice if you're building for a mixed-framework environment or want a single platform handling forms, identity, and edge functions across multiple non-Next.js sites.

Railway and Fly.io are worth evaluating if you need persistent server processes (a full Node.js backend, a Sanity Studio running on a custom port) and want to avoid per-seat pricing — though they require more infrastructure management.

For most Next.js + Sanity teams landing in 2026: Netlify free works as a scratchpad, but the build-minute ceiling and single-member Starter limit push serious projects to Pro or Vercel before the first billing cycle.

Keystatic Pricing 2026: Free Tier Limits, Cloud Costs & When to Upgrade

Nayan Kyada — Sun, 30 Aug 2026 10:02:03 +0000

Keystatic is one of the few headless CMS options that started genuinely free — open-source, file-based, no account required for local editing. That makes its pricing story interesting, because the cost only enters the picture when you need collaborative cloud features. Here's what you actually pay across every tier in 2026.

What Keystatic pricing looks like in 2026

Keystatic ships in two modes: local mode (files on disk, zero cost, no cloud dependency) and GitHub mode (reads and writes directly to a GitHub repo). Neither mode requires a Keystatic account. The free tier is not a trial — you can run a production site on GitHub mode forever without paying anything, as long as you're comfortable with editors authenticating through GitHub.

The paid layer is Keystatic Cloud, which adds a user-friendly auth wrapper so non-technical editors don't need a GitHub account to log in. That's the product you're actually paying for.

Tier	Monthly cost	Editors	Repos / Projects	Notes
Open Source (local/GitHub mode)	$0	Unlimited (GitHub auth)	Unlimited	No Keystatic account needed
Keystatic Cloud – Hobby	$0	1	1	Personal projects only
Keystatic Cloud – Solo	$9/mo	3	3	Good for freelance client handoff
Keystatic Cloud – Team	$29/mo	10	10	Covers most small agency projects
Keystatic Cloud – Pro	$79/mo	30	30	Mid-size teams or many client sites
Enterprise	Custom	Unlimited	Unlimited	SSO, SLA, volume pricing

Prices as published on keystatic.com in August 2026. Verify before quoting a client.

What the free tier actually covers

The open-source path is genuinely capable. You get:

Full Studio UI, identical to the paid version
File-based storage (Markdown, YAML, JSON) committed directly to your repo
GitHub mode for up to however many GitHub-authenticated collaborators you want
No API rate limits from Keystatic itself (GitHub API limits still apply)
Self-hosting the Studio inside your Next.js app at any path you choose

The constraint is GitHub authentication. Every editor needs a GitHub account and must be added to the repo as a collaborator. For a developer handing off a blog to another developer, this is fine. For a marketing manager who has never seen GitHub, it's a non-starter.

What actually triggers an upgrade

You need Keystatic Cloud as soon as a non-technical editor needs to log in. That's the only hard trigger. Everything else — content types, field count, build frequency, image storage — is handled by your repo and your deployment platform, not by Keystatic.

Secondary reasons to upgrade:

Multiple client projects: The Solo plan's three-project cap is the first real constraint for freelancers. A busy freelancer managing five or more client sites hits the Team plan.
Larger editorial teams: The Team plan covers ten editors. If a client's content team grows past that, Pro at $79/mo is the next step.
You want to remove GitHub branding from the login screen: Keystatic Cloud provides a clean, brandable auth flow.

There is no storage pricing, no transformation pricing, no CDN bandwidth fee from Keystatic. Images go into your Git repo (fine for small sites, bad practice for media-heavy sites) or you point field definitions at an external bucket (S3, Cloudflare R2, etc.). That external storage is your cost, not Keystatic's.

Keystatic vs the CMS tools you're already comparing

If you're evaluating Keystatic against Sanity, Payload, or Contentful, the pricing model is structurally different from all three:

Sanity charges on API request volume and dataset seats above the free tier. Heavy read traffic can push you to $99/mo or beyond on Growth.
Contentful charges per space and per user — their $300/mo cliff is well-documented and hits fast.
Payload is open-source with no SaaS fee, but you own the infrastructure (database, hosting, backups).
Keystatic charges only for the auth proxy (Keystatic Cloud). Infrastructure and storage are your problem, which means costs are predictable and low for content-light sites.

For a small marketing site where a founder or one editor needs to update copy and blog posts, Keystatic Cloud Solo at $9/mo is likely the cheapest managed editorial experience you'll find that doesn't require running a database or a separate CMS server.

Where Keystatic gets expensive relative to alternatives

Keystatic's Git-native model has a real cost ceiling problem for media-heavy projects. Images committed to a GitHub repo bloat your repository over time and slow down clone operations. The workaround — external media storage — requires you to wire up S3 or equivalent yourself, adding infrastructure cost and configuration overhead that Sanity (which includes a CDN-backed asset pipeline in its free tier) handles out of the box.

For a site with hundreds of images updated regularly, Sanity's asset pipeline is cheaper in engineering time even if Sanity's monthly bill is higher. For a content-light site — documentation, changelog, simple blog — Keystatic free mode plus $9/mo cloud auth beats almost everything.

The realistic cost for a client project

A typical freelance handoff: you build the Next.js + Keystatic site, the client needs one non-technical editor to update content.

Keystatic Cloud Solo: $9/mo ($108/year)
Vercel Hobby or Pro for hosting: $0–$20/mo
GitHub repo: $0 (private repos are free on GitHub Free)
Domain: ~$15/year
External image storage if needed: $0–$5/mo on Cloudflare R2

Total annual CMS-related cost: $108–$228, depending on image strategy. That's the lowest end of any managed headless CMS for a simple editorial handoff in 2026.

When Keystatic stops making sense

Keystatic is not the right tool when:

You need structured content reused across channels (API-first CMSes handle this better)
Your content team is larger than 30 editors and has complex role requirements
You need live preview with real-time collaborative editing
Your build pipeline can't tolerate a GitHub webhook triggering a full rebuild every time an editor saves a draft

For those cases, Sanity or Contentful are the practical alternatives. But for a developer-owned site or a small client with a single editor, Keystatic's pricing is hard to beat.

Kontent.ai Pricing 2026: Free Tier Limits, Per-Environment Costs & When to Upgrade

Nayan Kyada — Sat, 29 Aug 2026 11:15:28 +0000

Kontent.ai pricing is surprisingly opaque for a modern headless CMS — the marketing page lists feature tiers but buries the numbers that actually matter: environment limits, API call caps, and the seat model that quietly inflates your bill. This breakdown cuts through it with the real figures as of August 2026.

How Kontent.ai structures its plans

Kontent.ai operates on three commercial tiers — Starter (free), Business, and Enterprise — plus a self-serve trial pathway that lets you explore paid features for 30 days before committing. The distinguishing axes are: environments, content items, API calls per month, custom roles, and webhook destinations. Languages and locales are available on all plans but the number of active language variants caps out on Starter.

Feature	Starter (Free)	Business	Enterprise
Environments	2	5	Custom
Content items	500	Unlimited	Unlimited
Users/seats	3	Custom (per-seat billing)	Negotiated
API calls/month	10 000	1 000 000+	SLA-backed
Custom roles	—	✓	✓
Webhooks	3	Unlimited	Unlimited
SSO / SAML	—	Add-on	Included
SLA uptime	99.5%	99.9%	99.99%
Support	Community	Business hours email	Dedicated CSM

Business plan pricing is quote-driven and per-seat. From conversations with their sales team and public community data points, typical starting prices for a five-seat Business plan land around $990–$1 200 per month billed annually. Single-seat developer access is sometimes available at ~$250/month as an add-on. Enterprise is fully negotiated.

What the free Starter tier actually gives you

The 500-content-item ceiling is the constraint that bites first. A modest blog with 200 posts, a handful of author records, navigation singletons, tag taxonomies, and a few landing pages will hit that ceiling faster than you expect — especially if you model rich content with many granular content types. On Sanity's free tier you get unlimited documents; on Contentful's free tier you get 25 000 records. Kontent.ai's 500 is materially lower than both direct competitors.

The 10 000 API call per month cap is also restrictive for any production site. A Next.js App Router site doing ISR revalidation on 50 routes every 60 seconds burns through roughly 72 000 API calls per day. You cannot run a production Next.js site on the free tier without hitting that wall — it is a sandbox tier, not a launch tier.

The 3-environment limit means you get one production and one staging environment, with one left for local or preview work. That is workable for a solo developer but breaks down as soon as you need a client UAT environment separate from staging.

Where per-environment costs add up

On Business, extra environments beyond the five included are billed as add-ons. Community data suggests roughly $100–$150 per additional environment per month. If you run a setup common in agency work — production, staging, UAT, feature branch, and a long-running content-migration environment — you will be paying for at least one overage environment from day one of the Business plan.

The per-seat model is the other growth trap. Unlike Sanity, which charges on API usage and does not bill per editor seat on its Growth plan, Kontent.ai Business is seat-based. Onboard a marketing team of eight and your cost scales directly with headcount. For agencies handing off to a five-person client content team, that immediately affects whether the contract price makes sense.

What actually triggers an upgrade from Starter to Business

Three things reliably force the upgrade:

Content item count crosses 500. There is no soft warning — you get locked out of creating new items. Migration-heavy projects will hit this even before the site launches if schemas are being imported.
API call volume. Any real ISR or on-demand revalidation pattern exceeds 10 000 calls per month trivially. Even moderate editorial traffic on a Next.js site with preview mode enabled will do it.
Custom roles. If your client needs editors who cannot accidentally publish or delete, you need custom roles, which are Business-only. This is the governance gate for every agency handoff.

Kontent.ai vs Sanity and Contentful on cost

CMS	Free content items	Free API calls	Paid entry price	Seat model
Kontent.ai	500	10 000/month	~$990/month (5 seats)	Per seat
Sanity	Unlimited	500 000 CDN req	$15/user/month (Growth)	Per seat (editors)
Contentful	25 000	Unlimited (reasonable use)	$300/month (Basic)	Per seat

Sanity's free tier is significantly more generous for developers running early-stage projects. Contentful's $300 Basic tier is cheaper than Kontent.ai's Business entry point but comes with its own 25-seat cap and a jump to $2 100/month for Scale. Kontent.ai sits in the middle on features but leans toward the expensive side relative to what the free tier allows.

API call billing and CDN delivery

Kontent.ai serves content through a global CDN backed by Fastly. Delivery API responses are cached, which means most production read traffic does not count against your API call quota. The Management API calls — schema changes, content creation from scripts, import tooling — do count. If you are running an automated publishing pipeline or syncing content from an external source, model your Management API call budget carefully before committing to a plan.

Is there a self-hosted option?

No. Kontent.ai is fully cloud-hosted and SaaS-only. There is no community edition, no Docker image, and no option to run it on your own infrastructure. If data residency or self-hosting is a requirement, this is a blocker — Payload CMS or Directus are the realistic alternatives in that case.

The decision heuristic

Use Kontent.ai Starter for prototyping and small internal tools under 400 content items. If you are scoping a production project for a marketing team with more than three editors, budget for Business from day one — the free tier is not a viable production tier for Next.js projects with any real revalidation pattern. At the Business entry price of ~$990/month, compare it honestly against Sanity Growth (which runs $15 per editor per month and includes unlimited documents) before signing.

Cloudinary Pricing 2026: Free Tier Limits, Transformation Costs & When to Upgrade

Nayan Kyada — Fri, 28 Aug 2026 16:46:57 +0000

Cloudinary is the default image and video CDN recommendation you'll see across headless CMS tutorials — including Sanity setups where teams want more transformation control than the Sanity image pipeline offers. The pricing model looks simple until you hit your first billing surprise. Here's what the tiers actually cost and where the thresholds are.

How Cloudinary pricing works in 2026

Cloudinary bills on credits, not on individual resource units. One credit equals one of the following: 1 GB of managed storage, 1 GB of net viewing bandwidth, or 1,000 transformations. That normalisation sounds clean, but in practice transformation usage is almost always the first limit you hit — not storage or bandwidth — because every resize, crop, format conversion, or overlay counts as a separate transformation.

The free plan includes 25 credits per month. For a small marketing site serving pre-sized images in one or two formats, 25 credits is enough. For a Next.js site pulling Sanity assets and using Cloudinary's f_auto,q_auto auto-format pipeline with multiple breakpoints, you can drain 25 credits in a day if a page gets indexed and crawled hard.

Cloudinary plan tiers and real costs

Plan	Monthly price	Credits included	Overage per credit	Key limits
Free	$0	25	Not available — upgrade required	No video transcoding API, basic support
Plus	$89	225	~$1.00	Unlimited transformations (within credits), webhooks
Advanced	$224	600	~$0.90	Background removal AI, video, priority support
Enterprise	Custom	Custom	Negotiated	SLA, SSO, custom domains, dedicated infra

Overage on the free plan is not charged — you're cut off and assets stop transforming or delivering until the next billing cycle. That's a production outage risk that most teams don't realise until it happens. Upgrading to Plus is the first credible option for any site with real traffic.

The $89/month Plus plan is where most small-to-medium Next.js agencies land their client sites. 225 credits is roughly 225,000 transformations per month, which handles a typical content site with 50–100 pages, next/image serving three breakpoints, and both WebP and AVIF variants if you're using Cloudinary for format negotiation rather than Sanity's own auto=format parameter.

What actually eats your credits

Three patterns drain credits faster than teams expect:

1. Eager transformations on upload. If you configure Cloudinary to pre-generate multiple sizes and formats on asset upload — which the dashboard encourages — you're spending transformation credits immediately for every new image, regardless of whether those variants are ever served.

2. Named transformations not caching. Cloudinary caches transformed URLs, but cache keys are based on the full URL including transformation parameters. If your CMS generates slightly different crop parameters per image (common with Sanity hotspot data translated into Cloudinary g_auto gravity), each unique combination counts as a new transformation.

3. Video auto-quality. Any video transcoding via the q_auto or f_auto parameter on video assets counts against your transformation budget at a much higher weight than image transformations. The Advanced plan is essentially required the moment video enters the workflow.

Cloudinary vs Sanity image pipeline: cost comparison

For teams already on Sanity, the most common question is whether Cloudinary is worth adding at all. Sanity's own image CDN — accessed via @sanity/image-url — handles format negotiation (auto=format), quality, and width resizing with no per-transformation charge. The Sanity Growth plan at $15/month includes enough bandwidth for most sites. You only pay separately for Cloudinary if you need capabilities Sanity's pipeline doesn't have: AI background removal, overlays and text rendering, video transcoding, or face-detection cropping.

Capability	Sanity image pipeline	Cloudinary Plus ($89/mo)
WebP / AVIF auto-format	Yes (`auto=format`)	Yes (`f_auto`)
Width / quality params	Yes	Yes
Hotspot / focal crop	Yes (native)	Yes (`g_auto` or manual)
AI background removal	No	Yes (Advanced only)
Video transcoding	No	Yes (Advanced only)
Text / overlay compositing	No	Yes
Per-transformation billing	No	Yes

For pure image delivery on a Sanity-backed Next.js site, there's rarely a cost justification for adding Cloudinary. The Sanity pipeline covers 95% of what next/image needs. Where Cloudinary earns its fee is when the design calls for generated social share images, AI-cropped headshots, or video that needs adaptive bitrate variants without standing up your own FFmpeg pipeline.

The upgrade triggers to watch

Free → Plus: You hit the 25-credit ceiling in any month, or you need webhooks for cache invalidation coordination with Next.js ISR revalidation routes.

Plus → Advanced: You add video to the project, need background removal for product images, or your credit usage consistently exceeds 200/month. The jump from $89 to $224 is steep — model your transformation counts before committing.

Advanced → Enterprise: You need a contractual uptime SLA, SAML SSO for the media library, or your bandwidth alone exceeds several TB per month. Enterprise pricing is negotiated; most teams report landing between $500 and $2,000/month depending on volume.

What Cloudinary's pricing model hides

The credit system obscures the real cost structure: you're paying for transformations as a proxy for compute. Teams that cache aggressively at the CDN layer (Vercel Edge Cache, Cloudflare) and avoid redundant transformation variants can stay on the Plus plan indefinitely. Teams that let every page request trigger a new transformation — because they're passing dynamic width parameters rather than a fixed set — burn through credits at 10× the expected rate.

One practical rule: define a fixed breakpoint set (e.g. 640, 960, 1280, 1920) and use Cloudinary named transformations for your site's image variants. Pre-generate on upload for predictable cost. Avoid passing arbitrary w_ parameters derived from viewport width at request time.

If you're choosing between Cloudinary and Sanity's native pipeline for a greenfield Next.js site, start with Sanity's pipeline — it's included in what you're already paying — and add Cloudinary only when a specific capability gap forces the decision.

Storyblok vs Sanity for Next.js in 2026: An Honest Comparison

Nayan Kyada — Thu, 27 Aug 2026 15:22:54 +0000

Storyblok and Sanity are the two headless CMS options I get asked to compare most often by clients who've outgrown WordPress but aren't ready to commit to an enterprise contract. Both are production-grade, both have generous free tiers, and both work well with Next.js App Router — which makes the choice genuinely non-obvious. Here's how they actually differ when you're building a real project.

What each CMS is optimising for

Storyblok is a visual CMS first. Its entire product is built around a component-based block editor with a live preview pane that non-technical editors find immediately usable. You define "bloks" (their spelling), and the editor drags them onto a page canvas. The mental model is closer to a page builder than a structured content system.

Sanity is a structured content platform. Content lives as documents and fields, not pages. The editor experience is closer to a form than a canvas. That sounds like a downside, but it means your content is portable — the same article document can feed a web page, a mobile app, an RSS feed, and a JSON API without reshaping.

Neither framing is wrong. They're just solving different problems.

Developer experience with Next.js App Router

Sanity ships next-sanity, which gives you a typed GROQ client, Presentation (live preview) wired to App Router's draft mode, and Sanity TypeGen for end-to-end type safety. Setup is roughly:

// lib/sanity.ts
import { createClient } from 'next-sanity'

export const client = createClient({
  projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID!,
  dataset: process.env.NEXT_PUBLIC_SANITY_DATASET!,
  apiVersion: '2024-01-01',
  useCdn: true,
})

You write GROQ, fetch in server components, and ISR revalidation hooks into webhooks — all first-party. The schema lives in your repo, so you get version control on content structure.

Storyblok uses a REST API (v2) or GraphQL endpoint. The @storyblok/react SDK handles bridge communication for the visual editor. The pattern looks like this in a server component:

// app/[slug]/page.tsx
import { storyblokInit, apiPlugin, getStoryblokApi } from '@storyblok/react/rsc'

storyblokInit({ accessToken: process.env.STORYBLOK_TOKEN, use: [apiPlugin] })

export default async function Page({ params }: { params: { slug: string } }) {
  const storyblokApi = getStoryblokApi()
  const { data } = await storyblokApi.get(`cdn/stories/${params.slug}`, {
    version: 'published',
  })
  // render bloks
}

The Storyblok SDK has historically been heavier than Sanity's, and App Router RSC support arrived later. It works, but you'll hit edge cases around the bridge script (needed for the visual editor) conflicting with React 19 hydration. Sanity's Presentation tool is purpose-built for RSC and avoids that class of problem.

Editor experience

This is where Storyblok wins clearly for marketing teams that want drag-and-drop page composition. The visual editor shows the actual rendered page on the right while the editor manipulates content on the left. For landing page–heavy sites where the team is constantly rearranging blocks, that feedback loop is valuable.

Sanity's Portable Text editor is excellent for long-form prose, and Studio is highly customisable — you can build custom input components, structure the sidebar however you want, and use AI Assist for copy generation. But there's no built-in visual canvas. You can approximate it with Presentation, but it takes meaningful setup time.

For a blog or documentation-heavy site: Sanity. For a marketing site where editors expect to see the page as they edit: Storyblok.

Pricing comparison

	Storyblok	Sanity
Free tier	1 user, 25k API calls/mo, 1 locale	3 users, 500k API calls/mo, 2 datasets
Entry paid plan	Community €9/user/mo (approx)	Growth $15/user/mo
API call ceiling (free)	25,000/month	500,000/month
Locales (free)	1	1
CDN / asset delivery	Included	Included (Sanity CDN)
Self-host option	No	No (cloud only)
Overage model	Hard block / upgrade	Metered overages

Sanity's free tier is meaningfully more generous on API calls — 500k vs 25k is a real difference for a blog with decent traffic hitting ISR cache misses. Storyblok's per-user pricing climbs quickly once you add more than two or three editors. A five-editor team at Storyblok's entry plan costs roughly €45/month before asset overages; Sanity Growth for the same team is $75/month but includes significantly higher limits.

At scale, both platforms push you toward annual enterprise contracts. Storyblok publishes a "Business" tier and enterprise; Sanity has a "Business" plan at $949/month that unlocks custom roles, audit logs, and SSO. Neither is cheap once you need those features.

Schema and content modelling

Sanity schemas live in your codebase as TypeScript definitions. You version-control them, run TypeGen, and get end-to-end types from schema through GROQ query to React component. That is a genuine productivity advantage once the project is past initial setup.

Storyblok's component definitions live in the Storyblok dashboard and sync to your codebase via a CLI. It works, but the authoritative source of truth is a cloud dashboard, which complicates PR-based workflows. There's no equivalent of sanity typegen generate that derives TypeScript types automatically from your schema.

When I'd pick each one

Choose Storyblok if:

The client team will be composing pages visually, not just editing field values
The site is primarily marketing pages with high layout variability
The team has used visual page builders before and expects that workflow
Locale count stays low (multilingual costs jump fast on paid plans)

Choose Sanity if:

Content needs to serve multiple surfaces (web, app, API consumers)
The team values schema-as-code and typed queries
You're building a blog, docs site, or product with complex content relationships
API call volume is high or unpredictable (the free tier headroom matters)
You need RBAC, custom workflows, or AI Assist without an enterprise contract

The real differentiator

Storyblok and Sanity are not actually competing for the same project types most of the time. If a client frames it as "we want editors to build pages," Storyblok. If they frame it as "we have content that needs to be reliable, typed, and reusable," Sanity. The mistake I've seen is forcing the structured-content model onto a team that thinks in page layouts — that ends in frustration regardless of how clean the architecture is.

Hygraph Pricing 2026: Free Tier Limits, Per-Seat Costs & When to Upgrade

Nayan Kyada — Wed, 26 Aug 2026 05:03:21 +0000

Hygraph pricing is harder to decode than most headless CMS vendors because the cost model mixes seat-based fees, API operation limits, and content environment counts in ways that are not obvious from the marketing page. This post breaks it down concretely — free tier ceilings, what each paid tier actually unlocks, and the three triggers that reliably push projects off the free plan.

What the free tier actually gives you

Hygraph's free plan (called Community) is genuinely functional for solo developers and small proof-of-concept projects. As of mid-2026 the hard limits are:

Resource	Community (free)	Professional	Scale	Enterprise
Seats	3	3 included (+$15/extra)	5 included (+$15/extra)	Negotiated
Content API operations/mo	500,000	5,000,000	25,000,000	Custom
Management API operations/mo	500,000	2,000,000	10,000,000	Custom
Environments	1	2	5	Custom
Webhooks	3	10	Unlimited	Unlimited
Roles & permissions	Basic	Full RBAC	Full RBAC	Full RBAC + SSO
SLA uptime guarantee	None	99.9%	99.9%	99.99%
Asset traffic/mo	50 GB	250 GB	1 TB	Custom

The 500,000 operation ceiling sounds large until you factor in how Hygraph counts operations. Every field-level read in a GraphQL response counts separately — a query returning a blog post with five rich-text fields, an author, and an image asset can consume 8–12 operations in a single request. A site doing 50,000 page views a month with ISR and cold-start revalidations can hit the ceiling faster than expected.

Professional plan: $99/month, billed annually

Professional runs $99/month if you pay annually, roughly $120/month month-to-month. The 5,000,000 Content API operations gives most small production sites comfortable headroom. The addition of a second environment (staging + production) is the main structural reason teams upgrade — you cannot safely test schema changes on Community without it.

Extra seats above the three included are $15/seat/month. A content team of six editors therefore adds $45/month on top of the base, bringing realistic cost to $144/month billed annually.

The Professional plan still has a meaningful ceiling: no multi-region delivery, no content federation, and no environment branching beyond two. For a Next.js + Hygraph stack, the missing multi-region delivery means all GraphQL queries route through Hygraph's primary region. If your audience is global and you care about TTFB, this matters.

Scale plan: $499/month, billed annually

Scale is where Hygraph starts feeling like infrastructure rather than a SaaS tool. At $499/month annually the operation limits jump to 25,000,000 Content API operations and five environments. Multi-region content delivery is included, which can measurably improve TTFB for ISR-revalidated Next.js sites serving audiences across continents.

The five-environment allowance matters for agencies running multiple staging branches simultaneously. Projects using Hygraph's Content Federation feature — pulling in external REST or GraphQL sources and surfacing them through a unified Hygraph schema — also require Scale or above.

At this tier, seat pricing stays the same ($15/extra), but asset traffic jumps to 1 TB/month, which is sufficient for most media-heavy marketing sites.

Enterprise: custom pricing, roughly $2,000–$8,000+/month

Hygraph does not publish Enterprise pricing. From public case studies and community discussions, real-world contracts typically land between $2,000 and $8,000/month depending on operation volume, SLA tier, and support level. Enterprise adds:

99.99% SLA (vs 99.9% on lower plans)
SSO / SAML
Custom operation limits
Dedicated infrastructure options
Priority support with named account manager

If you are evaluating Hygraph at Enterprise scale, get a named quote — the list price negotiates meaningfully, especially for annual multi-year commitments.

The three things that actually force an upgrade

1. You need a staging environment. This is the single most common upgrade trigger. Running schema migrations directly against production is not viable once editors are active. Community's single environment forces a $99/month jump to Professional before most real projects reach launch.

2. You hit the operation ceiling mid-month. Hygraph rate-limits rather than overages-bills on Community and Professional — when you hit the cap, the API returns errors. This is a hard stop, not a soft slowdown. Projects with traffic spikes (product launches, newsletter drops) discover this at the worst moment. Monitoring your operation count in the Hygraph dashboard weekly is essential before you're confident in headroom.

3. Your content team grows past three people. Three seats sounds fine for a two-developer setup, but add a content strategist, a copywriter, and a marketing manager and you are already at six users. On Professional that is three extra seats at $15/month each — $45/month additional — before you have built anything. For agencies handing off to client teams, budget this into proposals.

Hygraph vs Sanity pricing at the same tier

For teams already evaluating Sanity alongside Hygraph, the cost comparison is real. Sanity's Growth plan is $15/user/month with no operation-count ceiling — just a dataset and API request model that does not penalise field-heavy queries the same way. Hygraph's GraphQL field-counting model makes it more expensive at high page-view volume than the headline price suggests. Sanity charges more predictably per seat; Hygraph charges less per seat but more per query.

If you want a fuller breakdown of the Sanity side, the Sanity CMS Pricing 2026 post covers the Growth plan thresholds in detail.

Summary

Hygraph's free tier is real and usable — 500,000 operations and three seats covers a solo developer's test project through early development. The jump to Professional at $99/month is almost inevitable the moment you add a staging environment or a second editor. Scale at $499/month serves high-traffic production sites and agencies managing multiple environments. Enterprise pricing is negotiated and worth pursuing aggressively if your volume justifies it. Budget for extra seats from day one — they add up before you notice.