Product

A content lake, a query language, and a studio that authors against both.

Achar is a content lake, a query language, and a studio: one place to model your content, one API to read it from anywhere, and a publishing flow your editors can follow without a deploy.

Start free See pricing

The content lake

Every document, in one addressable place

A project owns datasets, a dataset owns documents, and nothing is authored outside one. That is what makes "where does this sentence live" a question with one answer — and it is why a document can be referenced by id from a website, an app, a partner feed and a print pipeline without any of them holding a copy.

A draft is its own row, so editing never touches what is being served.
Assets live beside the documents that point at them, addressed by reference.
One export is the whole dataset: schema, documents, and the assets they use.

GROQ

One query paints the page

There is no join, because there is no second table. A GROQ query says which documents and then what comes back — filtering, ordering, slicing and dereferencing in one round trip, with a projection that returns exactly the fields the surface will render.

References are followed with `->`, so an author arrives as a name rather than an id.
Parameters (`$slug`) keep one query serving every page instead of one query per page.
The same query runs in the studio, so what an editor previews is what the site fetches.

Query explorerproduction

*[_type == "post" && featured]
  | order(publishedAt desc)[0...3] {
    title,
    "slug": slug.current,
    "author": author->{ name, role },
    "categories": categories[]->title
  }

2 documents read4 fields projected14 ms

[{
  "title": "Your content model is the product decision",
  "slug": "content-model-is-the-product",
  "author": { "name": "Maya Chen", "role": "Head of content operations" },
  "categories": ["Content operations", "Engineering"]
}]

The studio

A studio that draws itself from your schema

There is no page builder here and no field to drag. The schema declares what a post is, and the studio renders the editor for it — the right control for a slug, a reference picker that searches the documents it points at, a rich-text field that produces Portable Text rather than HTML. Change the schema and the studio changes with it, for everyone, immediately.

Drafts and published rows are separate documents, so a week of editing never touches what is live.
Publishing is a step somebody takes, with an intent, not a side effect of typing.
Required fields are required at the write, so a document cannot be saved half-shaped.

Real-time collaboration

Several editors, one document, no locking

Presence and document updates arrive over one connection, so two people can work in the same post and see each other's typing settle as it is committed. Nobody checks a document out, nobody overwrites anybody, and the history of who changed which field is a thing you can read rather than a thing you reconstruct.

Field-level conflict resolution, with revisions to compare against.
Presence that says who is in the document and where they are in it.
A review step for the person who is allowed to publish.

Delivery

Reads served from the edge, in one round trip

Every query is answered from a cache in front of the API, keyed by the query and the perspective it was asked at. A published page is bytes from the nearest edge; a preview is the draft, uncached, for exactly the person who is allowed to see it. Invalidate by tag when a document is published, and the pages that read it — and only those — are rebuilt.

Under 50 ms at p95 for a cached query, from anywhere on the network.
Tag-based invalidation driven by the publish webhook, not a full rebuild.
Assets on their own distribution, transformed on request rather than at upload.

Capabilities

Everything the platform does, in three groups.

Content is what you model and author. Platform is what reads, guards and delivers it. AI is what the same structured content makes possible — and it is a third group rather than a headline because it is a consequence of the first two, not a replacement for them.

One content lake

Every document, asset and schema in one dataset, addressable by id and queryable from any surface. Nothing is authored outside a dataset, so there is never a second place to look.

Structured documents

A document is an array of fields with a type, not a row with columns. Add a field to the schema and every surface can read it without a migration.

Portable Text

Rich text as an array of blocks and spans — renderable on the web, in an app, in an email, and countable in a query when something has to be audited.

Asset pipeline

Uploads go straight to storage with a presigned URL, never through the API. Images are served from a CDN with transform parameters decided at read time.

Integrations

The content goes where the work already happens.

Achar is a query endpoint and a webhook, so the interesting question is never whether it integrates — it is what you point at it. These are the ones teams ask about first.

Frameworks

Next.js

Read a dataset from a server component with the typed client, and let ISR revalidate on the publish webhook instead of on a timer.

Deployment

Vercel

Deploy previews that read the staging dataset, and a production build that is purged by the same event that publishes the content.

Automation

GitHub Actions

Run the seed script against a scratch dataset on every pull request, so a schema change is reviewed with the content it affects.

Collaboration

Slack

A channel told when a document is published, with the projection shaped to the three fields a reader of the message needs.

Design

Figma

Keep the copy in a design file and the copy in the lake the same, by anchoring a frame to a document and diffing on export.

Commerce

Shopify

Product storytelling lives in the lake and the catalogue lives in Shopify; a page reads both and neither has to be copied into the other.

Algolia

A webhook projection feeds the index with exactly the fields the search results draw, so an unpublished draft never becomes searchable.

Analytics

Snowflake

Nightly exports of a dataset into the warehouse, so content can be joined against traffic and revenue by people who will never open the studio.

Your content already wants to be structured.

Make a project, define a type, publish a document. The first three things you need are free, and the query you write for them is the same query you will be writing in three years.

Start free Read the docs