NomaCMS

You still start with an idea. Something annoys you, or you see a gap, or you just want a thing to exist that doesn’t. That part hasn’t changed.

What has changed is how quickly the idea runs into reality. It’s less “can we build this?” and more “why would anyone care, and how would they even find it?” Models and copilots can spit out code and copy that looks fine on the first pass. The bottleneck moved. It’s less about typing speed and more about taste, structure, and knowing what not to ship.

Discovery is weird now too. Traditional search still exists, but it’s not the only front door it used to be. People get pulled in through feeds, recommendations inside tools, AI summaries, word of mouth, or whatever their stack already ships with. So you end up shaping the idea twice: once for the product, and once for the world it has to live in. Not in a sleazy way. Just honestly. If nobody is going to stumble on you through a five word Google query, you need another path: integrations, APIs, community, partnerships, or a problem so sharp people go looking for the category even when they don’t know your name yet.

That can feel cynical if you let it. Like you’re not building what you believe in, you’re building what fits. I don’t think it has to be that bleak. It’s more like editing. You still have a point of view. You’re just forced to say it in fewer moves.

Then there’s the crowded room. Do we even need new software? There is already a lot of everything. And yeah, sometimes the answer is no. Another thin wrapper on top of a model is not a company, it’s a weekend. The stuff that still feels worth doing is usually narrower: a specific pain big players ignore, data and permissions that need to stay sane when generation is cheap, or a workflow that has to stay reliable even when the fun parts are automated.

I swing between optimistic and skeptical about all of this, often in the same afternoon. On good days, cheap generation is freeing. You spend time on the fuzzy human stuff: who this is for, what “good enough” looks like, what breaks if you’re wrong. On bad days, it feels like everything is a remix and you’re shouting into a hallway full of people selling the same hallway.

If you’re a founder, a buyer, or someone who just ships things, the questions end up similar even if the vocabulary changes. Who is actually stuck on a random Tuesday? What would they use if you vanished? What would make them switch anyway? If you can’t answer those without squinting, the problem isn’t AI. It’s clarity.

So creating software in this era is a bit stranger, a bit faster, and a lot more honest about distribution. You’re not the only person who can code anymore. You might still be one of the few people stubborn enough to hold a standard when the tools say “done.”

I’ve been working on Noma for quite a while now, and the hosted SaaS version is finally live: app.nomacms.com.

So yeah, it’s no longer just something you self-host. There are real workspaces, billing, proper multi-tenant isolation, and a dashboard you can just open and start using. No setup, no “clone the repo and configure things first”. It feels pretty good to finally reach this point.

From the beginning, I wanted Noma to be API-first. Before worrying about UI, I focused on building a content model that actually holds up in production. Things like collections and fields, singletons vs lists, validation, relations, locales with linked translations, assets, webhooks, and project-scoped API keys with clear permissions. The kind of foundation you don’t have to fight later.

Turning that into a SaaS was a whole different challenge. It’s not just “it works on my server” anymore. I had to deal with tenant database isolation, subscriptions and trials (I’m using Lemon Squeezy), file uploads that scale on S3 with direct and multipart flows, webhook delivery with logs you can actually inspect, and rate limiting in the right places. None of this is exciting to show in screenshots, but without it you don’t really have a product people can rely on.

On the developer side, I wanted the experience to be predictable. Something you can integrate without guesswork. There’s a typed @nomacms/js-sdk, consistent error responses, and patterns that work across Next.js, Nuxt, Astro, mobile backends, or anything else that speaks HTTP. The goal is that you don’t have to reverse engineer how things behave.

AI is also a core part of it, but not in a “let’s add a chatbot” way. A lot of real work now happens inside coding tools and agents, so ignoring that didn’t make sense. Inside the dashboard, there’s a Noma AI Assistant that can interact with your projects, schema, and content. You can also use AI directly in fields to generate content, rewrite, fix grammar, summarize, or translate without leaving the editor. For multilingual setups, there’s entry-level translation with locale linking built in.

Outside the dashboard, I added MCP support so tools like Cursor or Claude Code can operate on your project using standard environment config. There are also agent “skills” so these tools actually understand how Noma works, like auth and SDK usage, instead of guessing and breaking things on the first attempt.

If you want to try it, you can check it out at nomacms.com. There’s a 7-day trial.

And if you’re curious about any part of it, whether it’s tenancy, API design, or how the AI pieces fit together, I’m happy to go into details. I’ve been deep in this codebase for a long time, so fresh feedback is always useful.

We are excited to introduce NomaCMS, a headless content platform built for teams that want structured content, a clean API, and a real place for AI inside their workflow. This post walks through what NomaCMS is and what you can do with it today.

What NomaCMS is

NomaCMS is a headless CMS. Your content lives in a structured layer, and your applications read and write it through a REST API or our JavaScript SDK. The dashboard at app.nomacms.com is where you model your content, create entries, upload assets, manage locales, and configure webhooks. Your frontend stays completely separate, which means you can ship the same content to a website, a mobile app, an internal tool, or anywhere else that can make an HTTP request.

Structured content modeling

Content in NomaCMS is organized into collections, and each collection has its own fields. A collection can be a list, like blog posts or products, or a singleton, like a homepage or a settings record. Fields cover the types you would expect from a modern CMS, including text, long text, rich text, slug, email, password, number, enumeration, boolean, color, date, time, datetime, media, relation, JSON, and group. That means you can model a simple blog or a more involved product catalog without reaching for workarounds.

Entries support draft and published states, bulk create, update, and delete, and flexible filtering when you list them.

A REST API and a typed JavaScript SDK

Every project gets a REST API secured with API keys. On top of that, the @nomacms/js-sdk package gives you a typed client with grouped methods for projects, collections, fields, content, assets, and webhooks. A minimal setup looks like this:

```ts

import { createClient } from "@nomacms/js-sdk"

const noma = createClient({

projectId: process.env.NOMA_PROJECT_ID,

apiKey: process.env.NOMA_API_KEY,

})

const posts = await noma.content.list("posts")

```

The SDK maps API errors to typed exceptions and handles details like the project-id header for you, so you can focus on your application.

Assets, webhooks, and localization

The asset library handles file uploads, including direct and multipart uploads for large files, plus bulk upload and bulk metadata updates. Webhooks let you react to content and auth events, with delivery logs you can inspect when something looks off.

For multilingual projects, you can define locales at the project level, pick a default, and link translated entries together so your frontend can navigate between them cleanly.

Project authentication for your users

NomaCMS also handles end-user authentication for your application. Your users can sign up with email and password or sign in with social providers, refresh their sessions, and manage their own per-user API keys. Everything is scoped to the project, so you do not need to stand up a separate auth service just to let users log in to the app you are building on top of NomaCMS.

Built-in AI, without the lock-in

AI shows up in three clear places.

Inside the dashboard, the Noma AI Assistant can help you create projects, build collections, manage entries, and navigate the product through conversation. In any text or rich text field, inline tools let you generate, rewrite, expand, summarize, fix grammar, or translate content on the spot. And when it is time to translate a whole entry, one click can move it into another locale and link the translations together.

AI coding tools, first class

If you work in Cursor, Claude Code, or Windsurf, our MCP server plugs your editor straight into your project. It exposes tools for project, collection, field, content, asset, and webhook management, so you can say what you want in plain language and have it show up in your CMS.

To go further, the Noma Agent Skills package teaches your coding assistant how to use the SDK, follow our auth patterns, and integrate with Next.js, Nuxt, and Astro, so you spend less time explaining the basics every time you start a task.

Getting started

If you want to try it out, head to https://app.nomacms.com, create a project, install the SDK, and fetch your first entries. We will be sharing more guides and updates here on the blog as we roll out new features. Thanks for checking out NomaCMS.