Most comparisons between headless CMS products are feature tables, and a feature table flatters whoever wrote it. Everyone has localization. Everyone has an API. Everyone has preview. Line them up and the products look interchangeable, which is exactly the moment the decision gets made on price.
Here is the thing a table cannot show: every architecture leaves some work undone, and that work lands on a person. The question is not which product has more rows. It is which product leaves less for a team that does not have a platform engineer to hand it to.
The incumbents are good, and they are built for someone else
Worth saying plainly, because the rest of this only means something if it is honest.
Contentful has the deepest ecosystem in the category — an app marketplace, an integration for almost anything, and governance features that large organizations genuinely need. Contentstack does enterprise localization better than most: entry-per-locale with real fallbacks, which lets regional teams work independently instead of waiting on each other. Sanity has the best developer experience of the three. GROQ is a genuinely good query language, and a Studio you can rebuild in React is a real advantage if you have someone to rebuild it.
None of that is marketing puffery and none of it is in dispute. But all three are shaped for organizations that have a platform team — people whose job is to operate the CMS, write the glue, maintain the front-end conventions, and absorb whatever the API does not do for you.
If that team is one developer who also owns the app, the marketing site and the deploy pipeline, the work does not disappear. It just queues.
“What is at this path?”
Start with the question a website asks more than any other, because the answers are unexpectedly different.
A visitor requests /pricing. Your front-end has to turn that into content. In most headless CMSs you cannot ask that question directly — you can only ask a narrower one: which entry of this specific type has this slug?
In Contentful, querying by a field such as a slug requires the content_type parameter; leave it out and the API returns a 400. In Sanity you write the type list into the query yourself, something like *[_type in ["page", "article"] && slug.current == $slug][0]. Contentstack comes closest of the three, with a real url field you can query against.
The consequence is small and permanent. Somewhere in your codebase, a developer maintains the mapping between “shapes of URL” and “types of content” — and every time marketing invents a new kind of page, that mapping needs editing, testing and deploying before the page can exist.
ebitex Content answers the question you actually have. One request to the Delivery API asks what is at a path, and the response tells you which of three things it found: a page, a redirect, or nothing. Every page names the Template and Contract behind it, so your code dispatches on what came back rather than on what it assumed would be there.
That is one catch-all route for the whole site, written once. A marketer publishes a new kind of page and it is live, with no deploy, because the front-end never needed to know in advance what would be there. Change a page’s slug and the old path becomes a redirect on its own, rather than a line somebody remembers to add to a redirect map.
This was the founding design goal of the product rather than a feature that accumulated, which is why it holds all the way through: path resolution, redirects and typing are one answer, not three integrations.
The fields that quietly ruin your content
Open almost any real content model and you will find fields like variant, columns, alignment, theme, backgroundColour. They are there because a designer asked for a layout the model did not have, and a field was the fastest way to get it.
They are also why the model does not survive a redesign. Those fields describe how something looked on one page in one design, and now they live inside the content, travelling with it everywhere it goes.
Most headless CMSs give you two options and no third: put presentation fields on the content type and lose reusability, or hard-code presentation in the front-end and lose the marketer’s ability to change anything.
ebitex separates them as two parallel type systems. A Contract defines what a piece of content is — a product, a testimonial, a person. A Template defines a presentation type, and it carries its own settings as an ordinary Contract in your library, editable and versioned like any other. Rendering itself lives in your app, dispatched on the Template’s external id.
So variant and columns go where they belong: on the Template’s settings, not on the product. The product stays a product. When the redesign comes, you replace Templates and your content is untouched — which is the promise structured content made in the first place and mostly has not kept.
When the shape is wrong, nobody has to write a mapper
Here is the situation that costs small teams the most time, and it has no name in most products.
You have a Contract for a blog post. A designer wants the three latest posts on the home page as cards — and the card Template expects title, image and kicker, while your post has heading, media and excerpt. Same content, different shape.
Everywhere else this is a developer’s afternoon: a mapping function in the front-end, turning one shape into the other. Then another one, in the mobile app. Then a third, when a second front-end appears. They are invisible to editors, duplicated per consumer, and they drift.
ebitex has Adapters — named, reusable mappings from one Contract’s shape to another, built visually block by block rather than typed into a formula box, and stored in the CMS rather than in your code. One server-side engine applies them, so editor preview and live delivery cannot disagree, and there is no mapping evaluator shipped to the browser.
The practical effect is that “can we reuse this content over there?” stops being a ticket.
Five modifiers that compose
Be precise here, because this is where comparisons usually overclaim.
Contentful localizes per field too. That is not the difference, and anyone who tells you it is has not read their docs.
The difference is composition. ebitex has five field modifiers — Mandatory, Multiple, Localized, Contextual and Personalized — and they combine in one fixed, system-defined order. All thirty-two combinations produce exactly one well-defined stored shape. A localized field is a default plus a sparse map of overrides, so only the fields you actually translated carry one, and a field can be Localized and Personalized and a list without you or the product having to decide what that means.
Personalization is one of those five modifiers, not a separate product. In Contentful, personalization is a separately priced product available on Enterprise plans. In Contentstack it is native but enterprise-shaped. In Sanity you are expected to bring your own. In ebitex it runs in the same resolver that serves every ordinary delivery request, and the smallest thing it can vary is not a page or an entry but a single phrase inside a rich-text document.
Two honest limits, since this is the section most likely to be oversold. The largest unit that can be personalized is one field’s value — there is no whole-page personalization. And the CMS deliberately does not track whether anything has been translated; it will not tell you your French coverage is 60%, because it does not know.
Preview that an editor can actually use
Every CMS in this comparison has preview. What differs is how much has to be true about your website first.
Sanity’s visual editing works by encoding invisible markers into the strings it returns and having your front-end subscribe to live updates — excellent when your site hydrates in the browser, and unavailable when it does not.
In ebitex, an editor opens preview inside the CMS, sees their unsaved draft rendered through the real website, and clicks a numbered pin on any piece of content to edit the field behind it.
Sites that render entirely on the server and never hydrate are supported too, through a short-lived preview session the server reads the draft with. That mode is more limited and the product says so: no pins, editing happens in the side panel, and updates arrive as a debounced reload. A server-rendered site that does hydrate — a Next.js App Router app, say — uses the ordinary bridge with pins intact.
Types you did not hand-maintain
If your front-end is TypeScript, you have typed your CMS content by hand at least once, and it went stale at least once.
ebitex publishes a schema describing the delivered shape of your published content, and a CLI turns it into TypeScript. The distinction that matters: the generated types are the SDK’s own exported types — ComponentValue<Image>, RichTextValue — rather than lookalike structures that describe roughly the same data. Generated types therefore work directly with the SDK’s rendering components instead of needing to be reconciled with them.
They describe the delivered shape after server-side resolution, which is the mode nearly everyone uses, and the generated file says so in its own header.
What we are not going to pretend
ebitex is early, and pretending otherwise would undermine everything above.
The ecosystem is not close. Contentful’s app marketplace and Sanity’s plugin community are years and thousands of contributors ahead. If your shortlist depends on an existing integration with a specific third-party tool, check before you switch — you may be the person who builds it.
There are fewer answers in the wild. Search a Contentful error message and you get a decade of Stack Overflow. Search ours and you get our documentation, which we write carefully for exactly this reason.
Some things are pipeline, not product. Translation jobs are a complete workflow, but you supply the translation engine — there is no machine translation included.
We are a small company. ebitex software LLC is a Texas company, Content and Forms are live, and the DAM is not built yet. If you need a long compliance history and a procurement process, the incumbents are further along than we are.
And then the pricing
This was meant to be about technology, so it goes last, where it belongs.
Starter is $20 a month, Pro is $50, Scale is $250. Contentful’s Lite plan is $300 a month, and an additional space on it is $850 on top.
The number is not really the point, though. The shape is. Contentful’s Lite plan includes three locales; its free tier caps at 10,000 records and two environments. In ebitex, locales are not a line item on the plan at all, and there is no limit on Contracts on any tier — the modelling is never the thing you are metered on. Multiple environments with promotion between them start at Pro, which is $50, rather than being the reason to call sales.
If the commercial case is what you are weighing, we wrote about that separately in why ebitex is a good fit for small and medium-sized businesses. This post was about the architecture, because the architecture is what you live with after the invoice stops being interesting.
Where to start
Start a 14-day free trial of Pro — no card required — and model one real content type rather than a sample. The thing worth testing is not whether the editor is pleasant for ten minutes. It is whether your second page costs less than your first, and your tenth costs almost nothing.
The developer documentation is at developers.ebitex.io, including the Delivery API reference and the SDK guides.
This site runs on ebitex Content. This post was written as a Component, given an address on the Experience tree, and published through the same Delivery API any customer’s key reaches.
