DEV Community: Martin

Connect Neleto to Anything: The Native MCP Server and Connector Ecosystem

Martin — Tue, 21 Jul 2026 07:40:00 +0000

Most content tools make you leave them to get anything done. You export, you paste, you wire up a middleman, you babysit a sync. Neleto goes the other way: the CMS itself speaks the protocol your AI tools already speak, so the content lives in one place and the work comes to it.

That protocol is MCP — the Model Context Protocol — and it's built into Neleto natively. Not a plugin, not a community wrapper around a REST API, not something you stand up on the side. When you point Claude Code, Cursor, or Windsurf at your Neleto instance, they can read and write your pages, posts, events, translations, and files directly, while respecting the roles and permissions you already set. Your AI workflow and your CMS, finally connected.

What "native" actually buys you

There are a lot of CMS-plus-MCP stories floating around right now, and most of them are a thin shim someone bolted onto an existing API. That works until it doesn't: the tool surface is narrow, the auth is awkward, nobody officially maintains it, and the moment the underlying API shifts, your agent breaks.

Native means Neleto exposes its own content model as first-class tools. An agent doesn't have to guess at your schema or reverse-engineer endpoints — it sees pages, blog posts, events, components, layouts, redirects, and translations as things it can actually operate on. "Create a draft," "publish this," "add a translation," "fix these redirects" — real operations, with your permissions enforced on every one. That's the difference between a demo and something you'd trust on a client site.

What this looks like on a Tuesday

Say a client emails you five new team-member bios and wants them live by end of day. In a normal CMS that's twenty minutes of clicking through forms. With Neleto you hand the email to Claude Code, tell it to create the pages, and it does — using the component you already built, in the language you already run, as drafts you review before anything goes public.

Or you're migrating a stubborn old site. You point your agent at the source, let it read the structure, and have it scaffold the content types with real sample data in Neleto so you can see the shape before you commit. Field mapping and taxonomy alignment — the tedious part — becomes a conversation instead of a spreadsheet. (We wrote up a full WordPress migration start to finish if you want the honest version.)

None of this needs a separate frontend, a second deployment pipeline, or a webhook you have to build and maintain. Everything a full site needs is already inside Neleto; MCP just lets an agent drive it.

Why we're leaning into connectors

MCP turned out to be the thing people actually want to talk about — it's consistently our most-read, most-shared content, and it's where the industry is heading. Through 2026, MCP has moved from a developer curiosity to production infrastructure: tens of thousands of public servers, adoption across every major AI tool, and a growing expectation that serious platforms speak it out of the box.

So the roadmap follows the demand. The native server is the foundation; connectors are the next floor. The goal is simple to say and a lot of work to earn: your Neleto content should be reachable from wherever your team already works, through agents you already trust, without you gluing services together by hand.

The honest status

The native MCP server is live and real — Claude Code, Cursor, and Windsurf work against it today, and it's one of the first things I'd want you to try. The broader connector ecosystem is being built in the open, the same way everything here is. If you're doing something with the MCP server we didn't anticipate, that's exactly the feedback that shapes what ships next — tell me about it.

Spin up a free instance at console.neleto.io, connect your agent to the MCP server, and let it write your first page. That moment — watching your CMS fill itself in from a prompt — is the whole pitch. You just have to see it once.

— Martin

Migrating a 40-Page Site Off WordPress: An Honest, Start-to-Finish Walkthrough

Martin — Tue, 14 Jul 2026 07:55:00 +0000

Most "switch away from WordPress" articles are sales pages in disguise. They tell you migration is a thirty-minute magic trick, skip the messy parts, and end with a button. This isn't that. This is the actual run we did last week, moving a real customer site — 40 pages, a blog with 60 posts, a contact form, and 1.2 GB of media — from a self-hosted WordPress install to Neleto.

Here's the honest headline: the content migration itself — export, import, media — took under an hour of hands-on work. The core content move is genuinely fast. But a real cutover isn't just the content. It's rebuilding the page-builder pages, setting up redirects, swapping the forms, moving the domain, waiting for DNS to propagate, and doing a proper QA pass across every page. Add all of that up and it was about a working day, start to finish — most of it waiting, not clicking.

That's the number we'd want someone to tell us. So here's exactly how it went, including the two things that went wrong.

Why this site was leaving WordPress

The customer is a small German agency running sites for their own clients. Their complaint wasn't ideological. WordPress worked. It was just expensive to keep working: a managed host at €39/month, a security plugin subscription, a caching plugin, monthly update windows where something usually broke, and a recurring worry about where plugin vendors were sending their visitors' data. For a DSGVO-conscious agency, that last one mattered most.

They wanted three things: predictable hosting in the EU, no plugin update treadmill, and content they could edit by prompt instead of wrestling with the block editor. That's a migration, not a tune-up.

Step 1 — Export (about 5 minutes of clicking, then a long wait)

WordPress exports its content as a WXR file (it's just XML) from Tools → Export. We pulled "All content." Media files don't live in that XML — they're referenced by URL — so we also grabbed the /wp-content/uploads folder over SFTP in parallel.

That folder transfer was the slowest single thing in the whole process. 1.2 GB over a residential connection isn't instant, and it ran in the background for the better part of an hour while we did other things. Nothing to babysit — but it's the first place the "30-minute migration" story quietly falls apart. The clicking is fast. The bytes moving are not.

Step 2 — Import into Neleto (about 10 minutes)

Neleto reads WXR directly. Pages became pages, posts became blog entries, and categories and tags carried over as-is. The importer maps WordPress's flat structure onto Neleto's content model automatically, so we didn't hand-build a single schema. Media uploaded to EU-hosted storage and the importer rewrote the old wp-content URLs to point at the new locations.

This is the part that actually is fast, and it's the part the sales pages are technically not lying about. If your site is content-heavy and plugin-light, you could be looking at your imported pages inside ten minutes.

Step 3 — Rebuild the page-builder pages (about 20 minutes)

Gotcha #1: Three posts used a page-builder plugin (Elementor) whose layout lives in proprietary shortcodes, not standard HTML. Those came in as raw shortcode text. The importer can't know what [ult_buttons] means — nobody can. We rebuilt those three pages by hand in about twenty minutes.

If your site leans heavily on a page builder, budget real time for this. It's the honest asterisk on every "one-click migration" claim, ours included. The upside: rebuilt in Neleto, those pages are now plain components anyone can edit — no shortcode syntax, no locked-in builder.

Step 4 — Redirects (about 15 minutes)

This is the step people forget and then lose their search rankings over. WordPress permalinks (/2024/03/post-name/) rarely match a new CMS's URLs one-to-one. We exported the old URL list, generated a redirect map, and imported it. Neleto handles 301s natively, so there was no .htaccess to babysit.

Gotcha #2: The old site had a ?p=123-style query permalink structure on a handful of legacy links from an email campaign. Those needed manual redirect rules. Five total. Worth checking your analytics for any odd inbound URLs before you cut over — it's five minutes now versus a month of 404s later.

Step 5 — Forms (about 15 minutes)

The contact form was a WordPress plugin posting to the site's own database. We replaced it with Neleto's built-in form handler, which stores submissions in the EU and emails the agency on receipt — no third-party form SaaS, no US data transfer. Rebuilding the fields and sending a couple of test submissions to confirm the mail landed took about fifteen minutes.

Step 6 — The domain and DNS cutover (about 10 minutes of work, then hours of waiting)

Here's the other place the clock stops being about you. Pointing the domain at Neleto is ten minutes of actual work: update the records, done. Then you wait for DNS to propagate. In our case most resolvers picked up the change within a couple of hours, but you can't rush it and you shouldn't cut over your MX and traffic until you've confirmed it's clean.

We kept the old WordPress host live during propagation so nobody hit a dead site mid-switch, watched the first agent and human requests land on the new stack, and only then decommissioned the old box. This is the single biggest reason "half an hour" is a fantasy: the internet's caches don't care how fast your CMS is.

Step 7 — QA pass (about 45 minutes)

Last, we walked every one of the 40 pages and spot-checked the 60 blog posts: images loading from the new EU storage, internal links resolving, the rebuilt Elementor pages looking right, redirects firing, the form emailing. Found and fixed a few internal links that still pointed at the old domain. Boring, essential, and the step that separates "it's live" from "it's actually done."

The honest clock

Hands-on-keyboard time: roughly 90 minutes across the whole thing.
Elapsed, start to finish: about a working day — dominated by the 1.2 GB media transfer and DNS propagation, both of which are waiting, not working.

So: fast where the sales pages promise fast (the content import), and honestly slow where every migration is slow (moving bytes, moving domains, checking your work). Anyone who tells you a real 40-page cutover is thirty minutes flat is selling you the demo, not the day.

What changed, measured honestly

The numbers after one week, not promises:

Hosting cost: €39/month → €59/month flat for the Neleto Team plan, but that one plan replaced the host and two paid plugins the customer was running (roughly €25/month combined). Net, slightly cheaper, with one bill instead of three.
Largest Contentful Paint: 2.9s → 0.8s on the homepage. The Rust backend and no plugin overhead do most of that work.
Update windows: gone. There's no plugin stack to patch.
Data location: every byte — content, media, form submissions — now sits on EU infrastructure with no US Cloud Act exposure.

What didn't improve: the three rebuilt pages took real human effort, and the agency had to relearn where a few settings live. Migration removes a treadmill; it doesn't remove a learning curve.

Should you do this?

If your WordPress site is content-heavy and plugin-light, a migration like this is genuinely a half-day-to-a-day job and pays for itself in saved maintenance within a quarter. If your site is a pile of page-builder layouts and 30 plugins, be honest with yourself: that's a rebuild wearing a migration costume, and it'll take longer.

Either way, the content import is the free, reversible part — so that's where to start. Run it, look at your pages inside Neleto, and then decide whether the rest of the day is worth it. For most content sites we've moved, it is.

We'll keep publishing these as we run them, gotchas included. If you want us to look at your specific site before you commit, the export step costs you nothing.

I turned a static HTML page into an editable CMS site with one prompt

Martin — Tue, 07 Jul 2026 08:00:00 +0000

There's a moment every web designer knows. The design is done. It's good. The animations are smooth, the type is dialed in, the custom cursor does the thing. And then the client asks the question that deletes your weekend:

"Can I edit this myself?"

Now you're not a designer anymore. You're a CMS plumber. You rebuild the whole thing in WordPress or Contentful, you map every headline to a field, you fight a templating language you don't love, and somewhere in there the animations break and you spend an afternoon getting your scroll-reveal working again. A week, gone. The design didn't get better. It just became editable.

I built Neleto partly to kill that week. This post shows you how — with a real example you can copy.

The 30-second version

Neleto is the only CMS with a native MCP server. MCP (Model Context Protocol) is the thing that lets tools like Claude Code, Cursor and Windsurf talk to other systems directly. Because Neleto speaks it natively, an AI assistant can read and write your CMS — create layouts, components and editable fields — without you touching a single admin form.

So the workflow becomes: you finish your HTML, you run one prompt, and Neleto turns it into a fully component-driven site where the client can edit every word and image — while your CSS, your animations and your JavaScript carry over untouched.

Not "AI-assisted." One prompt, finished site.

The example

I made a small design-studio landing page — call it Studio Nordlys. It's deliberately the kind of thing you'd actually ship: a fixed nav with a scroll state, a hero with a glowing animated blob and a staggered reveal, a scrolling marquee, an about section with an animated stat counter, a four-up services grid with hover states, a project gallery with image zoom, a dark process section, a big testimonial, a CTA banner, and a custom cursor that follows you around on desktop. CSS variables, keyframes, an IntersectionObserver, the works.

One file. The kind of page that normally makes the "make it editable" conversation painful, because there's so much in there you don't want to lose.

📥 Download the Studio Nordlys example — the HTML page plus the full prompt (.zip)

The prompt does the boring part

Here's the trick: the hard knowledge isn't the design — that's yours. The hard knowledge is how a CMS wants its layouts, components, templates and fields structured, and all the little ways you can get it wrong. So that knowledge lives in a prompt.

You point Claude at your file:

Use the Neleto MCP server to implement @studio-nordlys.html as a fully component-driven page. Every piece of content must be editable through the CMS — nothing hardcoded.

…and hand it the spec. From there Claude splits the page into sections, drops all your global CSS into a layout, turns each section into a component with its own scoped CSS and JS, and — the part that matters — replaces every headline, paragraph, label, link and image with a named, editable field. Your <h1>Design that moves people</h1> becomes a "Heading" field in the CMS. Same markup, same styling, now editable.

It assembles the page in your original order, wires the nav and footer into the layout so they show on every page, and hands you a live URL. Your animations still run. The custom cursor still follows the mouse. The stat counter still counts up. Because none of that was rebuilt — it was moved, intact, into the right places.

Why this is different from "AI website builders"

Two reasons, and they're the reasons I keep harping on.

You keep your design. This isn't a generator that invents a generic site from a text prompt. It takes your pixel-perfect HTML and preserves it. The AI does the CMS wiring, not the art direction. That's the right division of labor — machines are good at tedious structural mapping, you're good at taste.

It's a real CMS underneath, hosted in the EU. When you're done, the client logs into an admin where every section is a clean panel of plain-language fields. They can't break your layout because the layout isn't a field. And because galleries and lists are built as repeatable components, the client can add a fifth project themselves — not just edit the four you shipped. Images get scaled automatically on upload, so a client dropping in a 6 MB photo doesn't tank your performance score. And it runs on Neleto's Rust backend on EU infrastructure — no US Cloud Act exposure, which matters more to your clients every year.

For context on price: a setup like this on Contentful starts around €109/month and climbs fast with seats. Neleto starts free, with paid plans from €24/month. For an agency reselling to clients, that margin is the whole point.

The honest part

I'm not going to pretend it's magic with no edges.

It works best on a clean, sectioned page. Feed it tidy <section> wrappers and grouped CSS and the conversion is crisp. Feed it 4,000 lines of unlabelled <div> soup and you'll do some cleanup. The example page is clean on purpose — that's the lesson, not the cheat.

Occasionally a section converts twice, or a JavaScript effect needs a nudge to re-attach, or a field name gets mistyped. Every one of these is fixable by describing the symptom to Claude — "that section is duplicated, update it in place" — not by hand-editing CMS internals. The prompt already documents the common ones. But I'd be lying if I said it's always one-shot perfect on a gnarly page. On a clean page, it basically is.

And it doesn't do your job for you. It doesn't write your content strategy, fix your accessibility, or do your SEO. It preserves what you gave it. Garbage in, editable garbage out.

Try it

If you design websites and you've ever lost a week making one editable, this is worth twenty minutes of your evening. Grab the example page and the prompt, connect the Neleto MCP server to your editor, and watch a finished design become a client-editable site while you make tea.

📥 Download the example page + prompt (.zip)

Next time someone asks "can I edit this myself?" — yes. And it'll cost you a prompt, not a weekend.

— Start free at neleto.io · the only CMS with a native MCP server, hosted in the EU.

Neleto Console Is Live — and the Free Tier Is Open

Martin — Tue, 30 Jun 2026 08:00:00 +0000

Neleto Console is live at console.neleto.io, and the free tier is open for self-serve registration. Go there, create an account, pick the Free plan, and a few moments later you have your own Neleto instance running — no sales call, no card, no waiting on me.

That last part took longer to earn than I'd like to admit. The whole loop — provision a server, install the Neleto stack, issue a license, send your credentials — now runs untouched by human hands. If you've followed these build-in-public posts, you'll know that was the open seam I kept refusing to paper over on a pricing page. It's closed.

What you get on Free

One user, 1 GB of storage, and a real Neleto site — not a demo, not a sandbox that resets overnight. It runs on shared infrastructure, so there's no backup and the limits are real, but everything that makes Neleto Neleto is there: the integrated rendering and the page builder. Build your site by hand in the builder, or point Claude, Cursor, or Windsurf at the native MCP server and have it write pages for you by prompt. Both work. The AI angle is a big part of why I built this — but you don't need it to get value on day one.

When you outgrow Free, Starter is €24/mo, Team €59/mo, and Business €149/mo. Upgrading moves you off the shared box onto your own dedicated server — more room, more performance, and backups — without you having to migrate anything by hand.

Why give it away

The free tier exists for one reason: so you can actually experience Neleto before deciding anything. No demo, no sales deck, no expense approval — just a real site you can build on and judge for yourself. That's the only way I'd want to be sold a tool, so it's how we're selling this one.

And every instance, free ones included, runs on EU infrastructure by default. Your data sits under European data-protection law, not a US cloud provider's terms. For a lot of the people we talk to — agencies, public-sector teams — that's not a footnote, it's the whole reason they call.

The honest status

This is day one. The free tier is live and the self-serve flow works end to end — that's the hard part, and it's real. But the shared-tier limits are conservative on purpose while I watch how a hundred instances behave on one box under real traffic, and a few other paid-plan features are still on the bench. If you hit a rough edge in the first weeks, you're seeing a young system in public, which is exactly where I want it.

So go to console.neleto.io, sign up for free, and put it through its paces. If something's confusing, slow, or broken, I want to hear about it. We did this in the open so the first people through the door could shape what it becomes — and the door's open now.

— Martin

MCP Server Explained: The Deep Dive

Martin — Tue, 23 Jun 2026 08:00:00 +0000

The Model Context Protocol (MCP) has quickly become one of the most important developments in the AI tooling space since its introduction by Anthropic in late 2024. While many developers have heard of MCP, fewer understand what an MCP Server actually is, how it works under the hood, and why native implementation in applications like CMS platforms matters significantly.

This deep dive breaks it down clearly.

What is an MCP Server?

An MCP Server is the server-side implementation of the Model Context Protocol. It acts as a standardized interface that allows AI models and agents to discover, connect to, and interact with external tools, data sources, and applications in a secure, structured way.

Think of it as a universal adapter. Instead of every AI application building custom integrations for every tool (databases, CRMs, CMSs, file systems, etc.), the MCP Server provides a common language and protocol that any MCP-compatible client can use.

Key responsibilities of an MCP Server:

Resource discovery: Exposing what data and capabilities are available
Tool registration: Defining functions/actions the AI can call
Context provision: Supplying relevant, up-to-date information to the model
Permission enforcement: Ensuring the AI only does what it’s allowed to do
Secure communication: Handling authentication and controlled access

MCP Architecture: Client vs Server

MCP follows a client-server model:

MCP Client: Usually lives inside the AI application (e.g., Claude Desktop, Cursor, Windsurf, or custom agents). It initiates connections and makes requests.
MCP Server: Lives inside the target application (your CMS, database, internal tool, etc.). It responds to requests and executes actions.

This separation is powerful. It means:

AI tools don’t need to know the internal details of every system they connect to.
Application developers only need to implement the MCP Server once to become compatible with the entire ecosystem of MCP clients.

The protocol handles discovery, capability negotiation, and structured requests/responses, making integrations much more reliable than traditional custom API work.

Why “Native” MCP Server Implementation Matters

Not all MCP support is created equal. There’s a meaningful difference between:

Bolt-on / Proxy MCP servers — Built as middleware or separate services that sit in front of your application.
Native MCP servers — Deeply integrated into the core of the application, with direct access to internal data models, permissions, and business logic.

Benefits of native implementation:

Better security: The server understands your existing permission model natively instead of trying to replicate it.
Stronger consistency: Actions taken by AI agents follow the same rules and audit trails as human users.
Deeper integration: The AI can work with rich internal concepts (content types, relationships, workflows) rather than just raw data.
Lower latency & complexity: No extra network hops or translation layers.
Future-proofing: As the protocol evolves, native implementations can adapt more cleanly.

This is why platforms that ship with a native MCP server (like Neleto) offer a meaningfully better experience than those that rely on external proxies or custom integrations.

Security and Permissions Model

One of the biggest concerns with giving AI agents access to production systems is control. MCP was designed with this in mind.

A well-implemented MCP Server should:

Respect existing role-based access control (RBAC)
Allow granular scoping of what resources and actions are exposed
Maintain full audit logs of agent activity
Support human-in-the-loop approval workflows where needed
Never bypass application-level business rules

When done correctly, an AI agent using MCP should have the same (or more restricted) capabilities as a human user with the same role — nothing more.

This is a major advantage over older approaches like giving AI systems broad API keys or database access.

Real-World Use Cases in Content Management

While MCP has broad applications, it shines particularly well in content systems:

1. AI-assisted content creation

An agent can research, draft, and directly create or update blog posts, landing pages, or product descriptions inside the CMS.

2. Automated content operations

Agents can bulk-update metadata, reorganize content structures, translate content, or apply taxonomies consistently.

3. Intelligent content maintenance

AI can identify outdated content, suggest improvements, or keep related pieces in sync.

4. Developer + AI collaboration

While a developer builds new features or components, an AI agent can simultaneously update the corresponding content entries without manual handoff.

The key is that these actions happen inside the CMS with proper permissions and workflows — not as disconnected generations that someone has to copy-paste later.

How Neleto Implements the MCP Server

Neleto was designed with AI collaboration as a core principle from the beginning. Its native MCP server is deeply integrated into the platform’s architecture.

This means:

AI agents connect directly to Neleto’s data layer and permission system
They can create, read, update, and manage all standard content types (pages, blog posts, events, etc.)
Actions respect the same role-based permissions configured for human users
Changes are fully auditable through normal platform mechanisms
No additional infrastructure or middleware is required

Because the implementation is native, agents can work with Neleto’s concepts (layouts, components, translations, redirects) in a way that feels natural rather than fighting against a generic API layer.

This positions Neleto as one of the most AI-ready content platforms available today — not through bolted-on features, but through fundamental architecture.

The Bigger Picture: Why This Matters

We are moving from AI as a tool that generates text to AI as a collaborator that can take meaningful actions inside the systems we use every day.

For this transition to be safe and useful at scale, we need standardized, secure interfaces. MCP is rapidly becoming that standard.

Applications that implement native MCP servers will have a significant advantage:

They become part of the growing AI agent ecosystem
They reduce friction between development and content work
They future-proof their platform as agentic workflows become mainstream

For developers and agencies, this translates to faster workflows, less manual busywork, and the ability to offer clients more powerful capabilities without increasing operational complexity.

Getting Started with MCP in Neleto

If you want to experience a native MCP server in action:

Create a Neleto project (free plan available)
Connect an MCP-compatible client (such as Claude or Cursor with MCP support)
Grant the appropriate permissions
Start collaborating with AI agents directly on your content

The experience of having an AI that can actually do work inside your CMS — rather than just suggesting text — is qualitatively different.

Conclusion

An MCP Server is more than just another integration. It represents a new contract between applications and AI agents — one built on standardization, security, and native understanding of the host system.

Platforms that treat MCP as a core architectural concern (rather than an afterthought) will define the next generation of AI-augmented tools.

Neleto’s native MCP server implementation reflects this philosophy: AI should be a first-class participant in content workflows, not a disconnected generator that creates more work for humans.

The future of content management isn’t just faster tools. It’s collaborative systems where humans and intelligent agents work together seamlessly — and MCP is one of the key protocols making that future possible.

Neleto vs Contentful: Which CMS Should You Choose in 2026?

Martin — Tue, 16 Jun 2026 10:52:10 +0000

Choosing the right CMS has never been more important — or more confusing. The market is full of options, from traditional monolithic platforms to modern headless solutions. Two names that often come up are Contentful, the established enterprise headless CMS, and Neleto, the newer performance-focused, AI-native alternative.

Both are capable platforms. But they serve noticeably different needs.

This article breaks down the real differences so you can decide which one actually fits your team, budget, and goals.

Quick Comparison Overview

Starting Price

Neleto: Free / €24/mo
Contentful: Free / ~$300/mo
🏆 Winner: Neleto

Performance

Neleto: Rust backend (very fast)
Contentful: Good (depends on frontend + CDN)
🏆 Winner: Neleto

AI Integration

Neleto: Native MCP server
Contentful: AI features available, no native MCP
🏆 Winner: Neleto

Editor Experience

Neleto: Clean, intuitive admin
Contentful: Good but can feel developer-oriented
🏆 Winner: Neleto

Developer Control

Neleto: Full HTML + plugin API
Contentful: Excellent API & modeling
🏆 Winner: Tie (different strengths)

EU / GDPR Hosting

Neleto: Strong native EU option (Germany)
Contentful: Available but more complex
🏆 Winner: Neleto

Frontend Requirements

Neleto: Optional (built-in rendering)
Contentful: Required (headless)
🏆 Winner: Neleto

Best For

Neleto: Agencies, freelancers, mid-market, AI workflows
Contentful: Large enterprises, complex omnichannel
🏆 Winner: Depends

Total Cost of Ownership

Neleto: Predictable and low
Contentful: Can grow expensive quickly
🏆 Winner: Neleto

1. Pricing & Total Cost of Ownership

This is one of the clearest differences.

Contentful follows a usage-based model on top of base plans. While there is a free tier and a Lite plan starting around $300/month, costs can escalate quickly with API calls, bandwidth, and additional spaces. Many mid-sized teams report spending thousands per month once they scale.

Neleto offers transparent, predictable pricing:

Free plan for personal projects and testing
Starter from €24/month
Team from €59/month

There are no surprise usage bills for normal website operations, and you're not penalized for growing traffic in the same way.

Verdict: If budget predictability and lower total cost matter to you (especially for client work or growing businesses), Neleto has a significant advantage.

2. Performance

Neleto was built from the ground up in Rust, which gives it a substantial performance edge. Pages load faster out of the box, which directly impacts SEO, Core Web Vitals, and user experience.

Contentful is a mature platform with a strong global CDN. However, because it is purely headless, your actual site speed depends heavily on how you build the frontend and how you query the API. Many teams end up fighting performance issues that stem from architecture rather than the CMS itself.

Verdict: Neleto wins on raw speed and simplicity of achieving fast websites.

3. AI Capabilities (The New Differentiator)

This is where the gap is growing fastest in 2026.

Neleto includes a native MCP (Model Context Protocol) server. This allows AI agents (Claude, Cursor, Windsurf, etc.) to directly read from and write to your content — creating blog posts, updating pages, managing assets — while respecting your existing permissions and workflows.

Contentful has been adding AI capabilities, but it does not currently offer a native MCP server experience. Integrations tend to be more custom or one-way.

Concrete example: With Neleto + MCP, a developer can ask Claude to "write a new case study based on our latest project and publish it under the right category with the correct featured image." The agent can do this directly in the CMS.

This level of deep, native AI integration is still rare among traditional headless CMS platforms.

Verdict: If you want to work with AI agents instead of just generating text in a separate tool, Neleto is currently ahead.

4. Developer Experience vs Editor Experience

Contentful excels when you have strong development resources and need sophisticated content modeling. Its API-first approach and GraphQL support are excellent for complex, omnichannel projects.

However, many teams report that the editing experience can feel secondary to the developer experience. Non-technical users sometimes struggle or require developer support for certain tasks.

Neleto was explicitly designed with both sides in mind:

Developers get full control over HTML, layouts, a plugin API, and direct database-like access when needed.
Editors and clients get a clean, modern admin interface that requires almost no training.

It also includes built-in rendering, so you're not forced to build a separate frontend application for every project.

Verdict: Neleto offers a better balance for most agencies and teams that serve non-technical clients.

5. Hosting, Compliance & Data Residency

For European companies or anyone serving EU users, this has become a serious consideration.

Neleto gives you a clear choice at signup, including EU/Germany hosting powered by Hetzner. This makes GDPR compliance and data sovereignty significantly more straightforward.

Contentful operates globally with data centers in multiple regions. While EU options exist, the company is US-based, and compliance often requires more configuration and legal review.

Verdict: Neleto is the simpler and more transparent choice for EU-focused teams.

When Contentful Makes Sense

Contentful remains a strong choice if you:

Are a large enterprise with highly complex, multi-brand content models
Need deep omnichannel delivery across many digital properties
Already have heavy investment in a specific frontend stack and composable architecture
Have a large budget and dedicated development team
Value the maturity and extensive marketplace of a long-established platform

When Neleto Makes More Sense

Neleto is usually the better fit when you:

Want fast websites without fighting performance
Need predictable, affordable pricing (especially for client work)
Want native AI agent capabilities today (via MCP)
Serve European clients or need strong GDPR/EU data residency
Value a clean experience for both developers and non-technical editors
Don't want to be forced into a full headless + frontend framework setup
Are a freelancer, agency, or mid-sized business that wants modern capabilities without enterprise complexity

Final Verdict

Contentful is a powerful, battle-tested platform that continues to serve large organizations well. It's not going away.

However, for a growing number of developers, agencies, and businesses in 2026, Neleto offers a more modern, faster, more affordable, and AI-native alternative — especially if you value simplicity, performance, and European compliance.

The best CMS is the one that gets out of your way and lets you deliver great websites efficiently. For many teams today, that CMS is Neleto.

Ready to compare them yourself?

Try Neleto for free and see how it feels for your next project. If you're currently on Contentful and curious about migrating, we also have a WordPress importer (and are happy to discuss Contentful migrations too).

Bots Just Out-Numbered Us: What the Agentic Web Means for Your CMS

Martin — Tue, 09 Jun 2026 07:00:00 +0000

It finally happened, and it happened early.

According to Cloudflare Radar data — flagged by SemiAnalysis and confirmed by Cloudflare CEO Matthew Prince — automated traffic has surpassed human traffic on the open web for the first time in history. Bots and AI agents now account for roughly 57.5% of HTTP requests to HTML pages, with humans down to 42.5%.

The headline number is striking on its own. What makes it a genuine inflection point is when it arrived and what caused it. Prince had publicly predicted this crossover wouldn't happen until the end of 2027, and it showed up roughly 18 months ahead of schedule. The thing that pulled it forward wasn't the search crawlers and scrapers we've lived with for two decades. It was agentic AI — autonomous agents browsing, comparing, and acting on behalf of real people.

The web has quietly become an environment where machines do most of the reading, while we keep building it for the people who now make up the smaller half.

Why This Is Important
For twenty-five years, every website on the internet rested on one quiet assumption: a human will look at this. We optimized for human eyes — layouts, hero images, hover states, cookie banners, the whole ritual. The entire stack, from page-builders to analytics, assumes a person on the other end.

That assumption is now wrong more often than it's right.

Here's what's actually changing, and why it matters for anyone who runs a website:

One human now generates dozens of page visits through agents. When a person asks an AI agent to "find me the best mirrorless camera under €1,500 and book the cheapest one in stock," that single intent can fan out into thousands of page requests across hundreds of sites. The person never opened a browser; their agent opened hundreds. Your traffic graph is increasingly a record of machines reading your content.

Agents read differently than people do. A human will tolerate a slow, cluttered, JavaScript-heavy page because they want the thing badly enough to wait. An agent has no such patience. It wants structured, fast, machine-readable content, and when a site is slow or hostile to automated access, it simply moves on to a competitor that's easier to read. Being legible to agents is turning into a ranking and revenue question, not a technical curiosity.

The traffic that matters is shifting from impressions to actions. The old web rewarded getting in front of eyeballs. The agentic web rewards being the source an agent trusts and actually uses to complete a task. When an agent can reliably read your product data, your availability, your documentation — and ideally write back to it — you're in the workflow. When it can't, you're invisible, however beautiful the page looks to a human.

And this is accelerating. AI-driven traffic grew roughly 8× faster than human traffic across 2025. A milestone that landed 18 months early marks the beginning of a steep curve, not a one-off spike.

So the question every site owner, agency, and developer now has to answer is uncomfortably simple: is my content built for the audience that's actually showing up? For most sites, the honest answer is no — they're still built for the 42.5%.

Why Neleto Is the Best Thing You Can Do About It
Most teams will respond to this news the way teams usually do: by bolting something on. An AI plugin here, a scraping policy there, maybe a hastily written llms.txt. That approach treats agentic traffic as an edge case to be managed after the fact.

Neleto was built on the opposite assumption — that agents are a primary audience, not an exception.

It's a CMS written in Rust with a native Model Context Protocol (MCP) server, as far as we know the only CMS with one built in from the ground up rather than glued on later. That single architectural decision happens to be exactly what the agentic web demands.

Agents can read and write your content, safely. Most "AI integrations" let a model read a page and nothing more. Neleto's MCP server lets AI agents — Claude Code, Cursor, Windsurf, anything that speaks MCP — securely read and update your live content, following the same roles and permissions a human editor would. Instead of scraping a rendered page and guessing at its meaning, the agent works with your content through a structured, permissioned interface designed for it. In a web where agents now outnumber people, your CMS speaks their language by default.

Speed is a feature when your readers are machines. Agents are relentless: they hit thousands of pages and they don't wait around. Neleto's Rust backend runs 10–50× more efficiently than typical PHP or Node.js stacks, so it stays fast and cheap to operate even under the heavy automated load that now makes up the majority of the internet. Fast pages get read, used, and ranked; slow ones get abandoned by humans and skipped by agents alike.

Structured content beats rendered guesswork. Neleto stores content as clean, typed resources — pages, blog posts, events, files, components, translations — with integrated rendering, so there's no fragile second stack for an agent to misread. That structure is what lets an agent use your data confidently instead of hallucinating around it.

You stay sovereign while you do it. The agentic shift doesn't suspend GDPR. Neleto offers DSGVO-compliant multi-region hosting (DE/EU, US, Asia), so opening your content to agents never means handing your data to someone else's cloud jurisdiction. Your content becomes agent-ready and remains yours.

And it costs a fraction of the alternatives. Neleto starts at €19/month and runs 5–7× cheaper than Contentful or Storyblok, while shipping the one thing they don't: a native MCP server. Future-proofing your content for the agentic web shouldn't require an enterprise contract.

The Cloudflare data is a warning shot for everyone still building exclusively for human eyeballs. The web's largest audience is now machines acting for people, and that audience is growing eight times faster than the old one. You can keep patching around that reality, or you can run your content on a system that was designed for it from day one.

As of this week's numbers, the agentic web is already here — and already the larger half of the internet. Neleto is how you publish for it.

Fast websites. Easy content. AI native.
Built for the 57.5%, before everyone else noticed.

Why EU Hosting Compliance Matters for Your Website

Martin — Mon, 01 Jun 2026 09:53:45 +0000

If you run a website that serves European users — or if you’re based in the EU yourself — hosting location is no longer just a technical detail. It has become a strategic and legal consideration.

In 2026, questions around data residency, GDPR compliance, and digital sovereignty are front and center for businesses of all sizes. Choosing where your website and its data live can affect everything from legal risk to user trust and even search engine performance.

The core issue: Where does your data actually live?

When you choose a hosting provider or CMS, your content, user data, images, and analytics often get stored on servers in a specific country or region. This matters because different jurisdictions have different laws regarding data access, privacy, and government requests.

Key concerns include:

GDPR compliance: The EU’s strict data protection regulation requires that personal data of EU citizens be handled with strong safeguards. Transferring data outside the EU/EEA can trigger additional legal requirements (such as Standard Contractual Clauses).
Schrems II and data transfers: Following court rulings, simply relying on old mechanisms for transferring data to the US became more complicated. Many organizations now prefer to keep data within the EU to reduce legal complexity.
Data sovereignty: Some companies and public sector organizations want (or are required) to ensure their data is stored and processed under EU jurisdiction.
Performance and latency: Hosting closer to your users generally means faster load times — which also helps SEO and user experience.

For many European businesses, especially those handling any form of personal data (even something as simple as contact forms or newsletter signups), EU-based hosting has become the safer, simpler default.

Why traditional hosting often falls short

Many popular CMS platforms and hosting providers are headquartered outside Europe. While they may offer data centers in the EU, the company’s legal jurisdiction, data processing agreements, and potential access by foreign authorities can still create uncertainty.

Common pain points include:

Unclear or complex data processing agreements
Difficulty proving full GDPR compliance to clients or auditors
Unexpected changes in terms or pricing
Limited transparency about where data is actually processed and backed up

For agencies and freelancers building sites for European clients, these issues often become recurring headaches during sales, onboarding, and ongoing maintenance.

How Neleto approaches EU hosting compliance

At Neleto, we built EU hosting compliance into the foundation of the platform — not as an add-on.

Here’s what that looks like in practice:

Server location choice at signup: You can select EU/Germany as your hosting region. Your data is stored on servers operated by Hetzner Online GmbH in Germany — a well-established, privacy-focused European provider.
GDPR-first design: When you choose EU hosting, your content and data stay within the EU/EEA, significantly simplifying your compliance story.
Transparent infrastructure: We’re clear about where your data lives and who operates the underlying infrastructure.
No hidden data flows: Neleto is designed so that choosing EU hosting means your primary data residency is in Europe.
Portability: Your content belongs to you. If you ever decide to leave, you can export everything — no lock-in, no drama.

This approach is especially valuable for:

German and EU-based agencies working with local clients
Companies in regulated industries
Organizations that need to demonstrate strong data protection practices to customers or partners
Anyone who simply prefers keeping European data in Europe

Beyond compliance: The business benefits

Choosing proper EU hosting isn’t just about avoiding fines. It also brings practical advantages:

Faster performance for European visitors
Stronger trust signals with privacy-conscious customers
Simpler sales conversations when pitching to EU clients
Future-proofing against evolving regulations
Peace of mind knowing your infrastructure decisions align with European values around data protection

In an era where privacy is becoming a competitive differentiator, being able to clearly communicate “Your data stays in the EU” is a meaningful advantage.

Making the right choice for your projects

Not every project needs EU hosting. If your audience is primarily outside Europe and you have no EU users or data, other regions might make more sense for latency or cost reasons.

However, for the growing number of websites that do serve European audiences — or are built by European teams — having a clean, transparent EU hosting option is increasingly important.

Neleto gives you that choice without forcing you into expensive enterprise plans or complex setups. EU hosting is available across our plans, including the free tier for testing.

Final thought

Website infrastructure decisions have legal and ethical dimensions now. Choosing a platform that makes EU compliance straightforward isn’t just responsible — it’s good business.

If you’re building or managing websites for European clients (or want to), having hosting you can confidently stand behind is one less thing to worry about.

Neleto was designed with this reality in mind.

What is the Model Context Protocol (MCP)?

Martin — Tue, 26 May 2026 06:00:00 +0000

If you’ve been following the rapid evolution of AI tools in 2025 and 2026, you’ve probably heard the term MCP more and more often. But what exactly is the Model Context Protocol, and why is it becoming such a big deal for developers and content teams?

In short: MCP is the emerging universal standard that lets AI agents securely and intelligently connect to external tools, data sources, and applications.

Think of it as “USB-C for AI.”

The problem MCP solves
Before MCP, connecting AI models (like Claude, GPT, or specialized coding agents) to real-world systems was messy and fragmented. Every integration was custom-built. Want your AI to read from a database, update a CMS, or trigger a workflow? You had to write brittle, one-off code for each tool.

This created several painful problems:

Security risks from ad-hoc integrations
High development effort for every new connection
Inconsistent behavior across different AI tools
Difficulty giving AI agents reliable, up-to-date context
As AI agents became more powerful and started moving from “chatbots that answer questions” to “agents that do things,” the need for a standardized, secure communication layer became obvious.

What is MCP exactly?
The Model Context Protocol (MCP) is an open standard (originally introduced by Anthropic in late 2024) that defines how AI applications and agents can discover, connect to, and interact with external resources in a structured, secure way.

It provides a universal interface for:

Reading and writing data
Calling tools and functions
Accessing contextual information
Maintaining proper permissions and auditability
Instead of building custom integrations for every AI client, developers can now implement an MCP server once. Any MCP-compatible AI agent can then connect to it using a standardized protocol.

This dramatically simplifies things for both sides:

AI tool makers get a reliable way to connect to external systems.
Application developers (like CMS builders) only need to implement the protocol once to become “AI-agent ready.”
Why MCP matters for content management
Content is one of the most valuable and frequently updated assets in any organization. Being able to let trusted AI agents safely create, update, translate, or organize content opens up powerful new workflows:

AI coding assistants that can directly update website copy while you build features
Automated content updates based on data from other systems
Smarter content suggestions and bulk operations with human oversight
Reduced manual busywork for editors and marketers
However, this only works safely and reliably if the CMS exposes a proper, permission-aware interface. That’s exactly what a native MCP server provides.

Neleto’s approach to MCP
At Neleto, we believe AI should be a first-class citizen in content workflows — not an afterthought. That’s why we built native MCP server support directly into the platform.

This means:

AI tools like Claude, Cursor, and Windsurf can connect directly to your Neleto instance
They respect the same role-based permissions you’ve already configured
Changes are auditable and follow normal content workflows
You don’t need custom middleware or fragile API glue
With Neleto’s native MCP server, you can go further in practice. For example, Claude can not only create a new blog post but also upload and set a featured image, apply categories and tags, and follow your normal publishing or review workflow — all while staying strictly within the role-based permissions you’ve already configured.

We didn’t bolt MCP on later. We designed Neleto with AI agents in mind from the beginning, because we believe the future of content management is collaborative between humans and intelligent agents.

The bigger picture
MCP is still relatively new, but adoption is growing quickly across development tools, databases, and now content platforms. It represents a fundamental shift in how we think about AI — moving from isolated models that only know what they were trained on, to agents that can safely act on live, permissioned data in the systems you already use.

For developers and agencies, supporting MCP is quickly becoming a competitive advantage. It future-proofs your stack and lets you offer clients more powerful, AI-augmented workflows without increasing complexity.

Ready to explore MCP in action?
If you’re curious about what AI-native content management actually feels like, Neleto gives you a clean, production-ready way to experience it today.

You can start for free and connect your favorite AI coding tools directly to your content. No custom integration work required.

The age of AI agents that can meaningfully help manage websites isn’t coming — it’s already here. MCP is the standard making it practical and safe.

Why Neleto Exists

Martin — Tue, 19 May 2026 07:00:00 +0000

every time. And yet, the tools we rely on to manage websites often feel like they’re stuck in the previous decade.

That tension is exactly why Neleto exists.

The friction we kept running into

As a digitalization partner working with mid-sized companies, we saw the same patterns again and again. Traditional CMS platforms were slow, bloated, and increasingly painful to maintain. Page speed suffered, security required constant vigilance, and every new feature seemed to demand another plugin. Clients loved the end result of a custom site but hated the editing experience — or worse, they accidentally broke things.

Headless and “modern” alternatives solved some problems but created others. They were powerful for developers, yet they often pushed complexity onto clients or required expensive frontend frameworks and ongoing specialist work. Pricing frequently scaled with seats or traffic in ways that punished growing businesses. And data residency? For European companies, that was rarely a first-class concern.

Then AI changed everything.

Tools like Cursor, Claude, and Windsurf started letting developers move dramatically faster. But the content layer — the actual website content that real businesses live and die by — remained disconnected from these new workflows. AI could help write code or generate text, but it couldn’t safely and natively update the live site without fragile custom integrations.

We didn’t want to keep patching around these limitations. We wanted to remove them.

What we decided to build

Neleto was born from a simple conviction: the best CMS should feel invisible to clients and empowering to developers — while being ready for the AI-native future that’s already here.

That conviction led to several non-negotiable decisions:

Performance as a foundation, not a feature. We built the backend in Rust. The result is websites that are dramatically faster than traditional PHP or Node.js solutions — often 10-50× quicker in real-world scenarios. Faster sites rank better, convert better, and cost less to run. For agencies and freelancers delivering client work, that speed advantage compounds every single day.
Two worlds, one system. Developers get full control: direct HTML access, a clean plugin API, and complete freedom to build exactly what they need. Non-technical editors and clients get a genuinely pleasant admin interface where they can manage pages, blog posts, events, translations, and files without training or fear of breaking the site. Role-based permissions keep everything safe and organized.
AI that actually belongs in a CMS. Neleto includes a native MCP (Model Context Protocol) server — the only one we’re aware of built into a CMS from the ground up. This means AI agents can securely read and write content directly, following the same permissions and workflows humans use. It’s not a bolted-on chatbot or a future roadmap item. It’s there today, ready for the way developers and teams are already working.
European pragmatism. We host in regions you choose, with strong GDPR compliance when you select EU/Germany servers. Your data stays where you want it. Pricing is transparent and predictable. There’s no vendor lock-in — export your content whenever you like. And migration from WordPress is built in, because we know many great sites still live there.

Built by people who ship websites every day

Neleto isn’t a theoretical product designed in a vacuum. It grew out of real client work at Triple-A Soft. We kept feeling the same friction points and eventually decided the best way to solve them for our clients (and ourselves) was to build the tool we actually wanted to use.

We made it affordable enough for freelancers and small agencies while powerful enough for teams. We included the content types and features most sites need out of the box so you spend less time configuring and more time delivering value. And we designed it to get better as AI capabilities advance, rather than having to be retrofitted later.

The future we’re building toward

Neleto exists because we believe the next era of the web belongs to teams that can move fast without sacrificing control, performance, or simplicity. Developers should leverage AI as a true collaborator. Editors should feel confident managing their own content. Businesses should own their data and their speed.

That’s the CMS we wanted. So we built it.

If you’ve ever felt the gap between how fast you can develop and how painful it is to hand a site over to a client…

If you’ve ever wished your content tools kept pace with your AI-assisted workflow…

If you care about performance, compliance, and not getting locked into expensive or bloated platforms…

…then Neleto was built for you.

We’re just getting started. Try it for free, explore the documentation, or reach out if you’d like to talk about how it fits your workflow. We’re building Neleto in public with real users, and we’d love to have you along for the ride.

Fast websites. Easy content. AI native.

That’s not just our tagline. It’s why we exist.
visit neleto.io