Weegloo vs Contentful

The short answer

Contentful manages your content. Weegloo manages your content and runs the rest of the service.

Of the platforms Weegloo is compared against, Contentful is the closest relative. Both are headless content platforms: you define a content model, editors work in a studio, and a delivery API serves published content to any front-end. Data modelling, localization, revisions and versions, dashboards, comments, tags, validation — that list exists on both sides. If you have used Contentful, the Weegloo console will feel familiar within an hour.

The difference is where each one stops. Contentful stops at content — members, file serving beyond assets, server-side logic, scheduled work, and hosting are somebody else's job. Weegloo carries the same CMS depth and then keeps going: end-user sign-in, permissions scoped to individual users, declarative server-side logic with no cold start, a cron scheduler, and static site hosting with custom domains.

What each one hands you out of the box

The three differences that actually decide it

1. Contentful is a CMS; Weegloo is a service platform that happens to be CMS-grade

"We only need content" is rarer than it sounds. A marketing site and a documentation portal still have to go somewhere, and Contentful does not host. So content sits on Contentful and hosting goes to Vercel or Netlify — two vendors, two bills, two dashboards, two deploy paths, even for the simplest product.

Weegloo has Web Hosting as a feature, custom domain included, so it ends in one place. The person editing content and the person putting the site online are inside the same console, and no outbound traffic passes between them. Even a "content only" product loses one piece of assembly.

And most products are not content only. Users sign up, upload something, and should see only their own rows. Something calls an external API and stores the result. A job has to run at 3am. It has to be hosted. On Contentful each of those becomes another vendor: an auth provider, a serverless runtime, a scheduler, a host. Weegloo has them as first-class resources under a single permission model.

Permissions deserve their own paragraph, because they are the most underestimated part.

Editor permissions are the same on both sides. Weegloo has exactly the same concept of Users and roles as Contentful — who may read, write, and publish which content type. Up to here the mapping is direct.

What differs is that there is one layer more. ServiceUser is an end user who signed up to your product, and they get their own roles too. createdBy: :self means a signed-in member reads and edits only the rows they created. It does not replace editor permissions — both layers exist together: the team operates the content, the member handles their own data. That is what turns a CMS into something you can build a member-facing product on.

2. Script — what makes a CMS do the backend's job as well

Build a product on a headless CMS and you always reach the same moment: "when a user submits the form, send an email and call an external API to store the response." A CMS does not do that, so you write a function and deploy it somewhere.

Weegloo has Script: declarative statements that read and write content, call external APIs, send email, verify signatures, branch, and loop. Sending email is one statement — no function to write and deploy.

And there are three ways to run it: direct call, content-change event, and cron scheduler. No round trip where a webhook calls something outside which then calls back through the API, and running a scheduled job once, right now, is just a call.

Code-authored functions are not impossible, they are deliberately not the answer — and in exchange there is no cold start, it stays light under heavy traffic, and the pricing is low.

3. The price curve is a different shape

Weegloo's published tiers are Free, Basic at $8 per month, and Pro at $80 per month, with Enterprise above. The Free tier is a working tier: 5 Spaces, 50 content types, 20,000 content items, 2,000 media items, 10 locales, 500,000 API calls a month, and custom-domain hosting.

Headless CMS pricing in this category is typically an order of magnitude higher once you pass the entry plan, and the jump between tiers is usually where projects get stuck. On top of that, with data, media, and server logic inside one platform there is no outbound traffic cost between them — a gap that widens with scale, and fewer round trips means lower latency too.

Check current numbers on contentful.com and on our pricing page.

If you do not write code, this is the strongest option here

Contentful is genuinely good at this part. Letting editors work without touching code is the whole reason headless CMS exists, and Contentful has done it well for a long time.

The difference is outside content. Taking members, replying to a form submission by email, running a nightly job, putting the site online — on Contentful every one of those calls for a developer. A non-developer can go as far as content and stops there.

Weegloo gives the same editing experience and covers what lies beyond it, so the point where a non-developer stops is much further along.

• The console is the product. Not just content and media — members and permissions too.
• Validation is a few clicks. Range, uniqueness, and format are set on the field.
• Server-side work is a DSL, not code. Email on an event or an external API call is a Script statement, and an AI agent writes it from a plain sentence. No function to deploy.
• Scheduled work is set in the console. Put a Script on a cron schedule.
• The site ships from here too. Custom domain included; no separate host to choose.

The Marketplace — where you do not even build the front-end

Contentful's app marketplace extends the editing screen. The Weegloo Marketplace installs the service itself — skipping both the modelling of content from scratch and the building of the screens that show it.

The Marketplace lists finished apps. One app can carry Content Type, Content, Media, SpaceRole, Locale, Script, Webhook, and the screens themselves as Web Hosting. Installing it brings all of that into your own Space — you are not a tenant on somebody else's service, you end up with a service where both the data and the screens are yours.

If the app includes screens, install it, swap in your own data, and it is a running service. If it has no front-end, you skip working out the data structures and writing Scripts from scratch — take what is already modelled and put your own front-end on top.

You do not have to use all of it

Reading Weegloo as "a full-stack backend, all or nothing" is a misunderstanding. Use only the part you need. Manage content here and leave the rest where it is, or use only media and CDN delivery.

For the wider view, a table sets Weegloo against ten platforms across twenty criteria — Directus, Strapi, Payload, Sanity, Appwrite, Supabase, Firebase, and Vercel included — in the comparison index. A capability a platform does not provide itself scores zero there.

Where Contentful is the better choice

• Large editorial organisations with formal workflow needs. Multi-step approval chains, scheduled releases coordinated across many entries, and a deep marketplace of integrations are areas where a long-established enterprise CMS is ahead.
• You have built a lot on top of it already. App marketplace and connectors, workflows you have tuned, systems you have integrated — if those are assets, moving may cost more than it returns.
• Procurement requires an incumbent. Sometimes the constraint is not technical.

What Contentful does not have and Weegloo does

• Editor accounts and roles are the same on both sides; Weegloo adds one layer more — the ServiceLogin your product's own members authenticate through, and the ServiceUser roles attached to them.
• Per-member data scoping through role filters like createdBy: :self — own rows only.
• Script: declarative server-side logic your front-end can call, with external API calls and email built in, and no cold start.
• A cron scheduler — the same Script also runs on a schedule.
• Web Hosting with custom domains for the front-end itself.
• Metric-based usage monitoring with threshold alerts — you see the limit coming by email.
• Low flat entry pricing: $8 per month for the first paid tier, and no outbound traffic between services.

FAQ

Is Weegloo a Contentful alternative?

Yes. Weegloo covers the same core — content modelling, an editorial console, revisions and versions, localization, tags, comments, validation, and a delivery API for published content — and additionally provides end-user authentication, per-user permission scoping, Script, a scheduler, and static hosting. For very large editorial organisations with formal multi-stage approval workflows, Contentful remains the more specialised tool.

Is Weegloo better even for a marketing site or docs portal?

Yes. Even when "content is all we need", the site still has to go somewhere, and Contentful does not host. So the simplest possible product still ends up with content on Contentful and deployment on Vercel or Netlify — two vendors. Weegloo includes Web Hosting with custom domains, so it ends in one place, with no outbound traffic between them. The editing experience is comparable; what remains is whether you assemble or not.

How much cheaper is Weegloo than Contentful?

Weegloo's first paid tier is $8 per month and the second is $80 per month, with a free tier that covers 20,000 content items, 500,000 monthly API calls, and custom-domain hosting. Headless CMS pricing in this category is normally far higher above the entry plan. On top of that there is no outbound traffic cost between services. Vendor pricing changes — compare current published prices on both sides.

Can a non-developer use it?

Yes. On content editing alone Contentful is good for non-developers too — that is what headless CMS is for. The difference is outside content: taking members, replying by email, running scheduled work, and putting the site online all call for a developer on Contentful, while here they are console settings and Script statements. An AI agent will write the statement from a plain sentence.

Does server-side logic run inside Weegloo?

Yes. Script reads and writes content, calls external APIs, sends email, and verifies signatures. Sending email is one statement, with no function to deploy anywhere, and it runs through all three paths: direct call, content-change event, and cron scheduler.

Does it support scheduled jobs (cron)?

Yes. Scheduler runs a Script on a cron schedule. The same Script can be called directly or triggered by a content-change event, so running a scheduled job once, right now, is just a call.

Does it support value validation?

Yes. Constraints such as range, uniqueness, and format are set on the field in the console when it is defined. Instead of a developer writing validation into application code, the platform enforces it.

How do I see usage? Will I know before I hit a limit?

Usage is shown in the console, per metric. And you can set a threshold as a percentage — when usage reaches it, an email arrives first.

Can I migrate from Contentful?

The concepts map closely — Contentful's content types, entries, assets, locales, and delivery API correspond to Weegloo's Content Types, Content, Media, Locales, and CDA. In practice the migration is a script that reads from one API and writes to the other.

Can my app's users log in?

Yes. ServiceLogin gives your product its own end-user directory with OAuth sign-in through Google, GitHub, Facebook, GitLab, LINE, Kakao, or Naver. Those members are distinct from the platform accounts your team uses, and their permissions are set by a role that can be scoped down to their own records.

Do I need an AI agent to use Weegloo?

No. Weegloo works perfectly well when a developer uses it the traditional way — there is a REST API and a console, and that is enough. It happens to expose its whole surface over MCP, so telling an agent like Claude, Cursor, or Codex what you want is usually faster. AI is an option, not a prerequisite.