Open-source headless CMS · AGPL v3

The headless CMS for the rest of us

Write your content model as a diagram. Get your database, REST API and editorial interface. Run it on ordinary shared hosting.
No account. No cloud setup. No credit card.

composer create-project elverdaderobutschito/lessheadcms

Or simply upload via FTP like it's 1998 again!

01 · schemaschema/magazine.puml
1@startuml
2enum Language {
3EN
4DE
5}
6
7class Author {
8+ name: string {title}
9+ bio: text?
10}
11
12class Article {
13+ title: string {title}
14+ slug: string {unique}
15+ language: Language
16+ body: richtext
17+ published: visibility
18}
19
20Article "n" --> "1" Author : written by
21Article "n" --> "0..1" Article : translation of
22@enduml
02 · databaseSQLite tables
indexes – created automatically
idx_article_written_by_author_id
idx_article_translation_of_article_id
table article table author 2 indexes GET /api/articles
03 · editorArticle › Edit
Published
Author → Author
Jana Wolter#7
Body richtext

A cup-and-cone hub is easier to service than it looks. You need two cone spanners, fresh grease and about forty minutes.

  • Remove the locknut on the non-drive side
  • Count the balls before you clean them
article · #1842
Cancel Save
fig. 1 — One PlantUML file becomes the database; the form follows from it.Simplified illustration – see real screenshots below

Runs where your clients already are.

  • Shared hosting
  • PHP 8
  • SQLite
  • FTP
  • Apache (.htaccess)

LessHeadCMS is a free, open-source (AGPL v3) headless CMS written in PHP. It uses SQLite, runs on standard shared hosting without Node.js, Docker or root access, and generates the database, a paginated REST API and the editorial interface from a PlantUML content model.

§ 01 — Why

Three decisions, made for you.

Fewer moving parts is a feature. Here is what that means in practice.

Model, don't configure.

Define your content structure in a diagram instead of assembling it through endless settings screens.

Host it yourself.

Deploy on conventional PHP hosting. No root access, Node.js runtime, or mandatory cloud platform.

Editors just get to work.

Generate an interface around the actual content model, so editors can focus on content instead of learning the CMS.

§ 02 — How it works

From diagram to API in three steps.

The example below adds one optional field to the model from fig. 1 and follows it all the way through.

  1. 01

    Define

    Write your content model in PlantUML.

    schema/magazine.pumledited
    12class Article {
    13+ title: string {title}
    14+ subtitle: string?
    15+ slug: string {unique}
    16+ language: Language
    17+ body: richtext
    18+ published: visibility
    19}
  2. 02

    Apply

    Review the schema diff, apply the changes, and use the automatic backup mechanism.

    Schema changes1 pending
    +article.subtitlestring, optional
    article.titleunchanged
    article.slugunchanged
    Backup is written before applying
    Apply changes Cancel
  3. 03

    Publish

    Manage content in the generated editorial interface and deliver it through the REST API.

    Article › EditGET /api/articles/1842
    Subtitle string, optional
    Forty minutes, two spanners
    "data"
    "id" 1842
    "title" "Adjusting cup-and-cone bearings"
    "subtitle" "Forty minutes, two spanners"
§ 03 — Features

Small core. Not a small feature list.

The parts real projects need once the demo is over: permissions, approval, media, languages, migrations.

Approval workflows, written as text

Define states, transitions, who may trigger them, who gets assigned and what happens on approval – in a short text file, versioned alongside your content model.

wf · workflowArticleWorkflow
1workflow ArticleWorkflow {
2state draft "Draft"
3state review "In review"
4state published "Published"
5
6flow draft -> review -> published
7
8draft -> review : submit {
9allowed=group:Editors
10assign=group:ChiefEditors
11}
12
13review -> published : approve {
14allowed=group:ChiefEditors
15action=set_visibility:true
16}
17
18review -> draft : return {
19allowed=group:ChiefEditors
20assign=initiator
21}
22}
Draft
In review
Published

Attached to a content type with one field: + state: ArticleWorkflow

Roles and field-level permissions

Decide per role/group/even user level  which fields can be edited, which are read-only and which stay hidden.

LessHeadCMS permissions screen for the entity Article: access checkbox, actions to forbid creating, editing and deleting, and fields such as Title and Subtitle that can be restricted individually

Media library

Upload once, use anywhere. Media fields hold an ordered list, so galleries keep their order.

LessHeadCMS media library list with preview thumbnails, titles and file details: a portrait photo titled El Butschito and a screenshot

Schema migrations

Every model change is shown as a diff first. A backup is written before anything is applied.

Schema diff in LessHeadCMS: an existing class with id, name and email, and a newly added optional field name_of_mother highlighted as line 23
Backup created · 3 changes ready

Your schema as an editable diagram

The PlantUML file is the source of truth, and the admin area can display it as an editable class diagram – entities, fields and relations at a glance, for you and for your clients.

Class diagram view in the LessHeadCMS admin area: the class Artikel related to Kategorie, Autor and Tag, a self-relation Original von, and the enumerations Sprache and ArtikelWorkflow

Multilingual content, by model

Languages are part of your diagram: a language field and a “translation of” relation. No hidden translation layer.

Class diagram excerpt: the class Artikel with fields including sprache: Sprache and a self-relation labelled Translation of with multiplicity 0..1

Backend in any language

Every label, button and message of the editorial interface can be translated – including the names of your own content types and fields. An English translation ships with LessHeadCMS; further languages can be added in the admin area or imported and exported as CSV files. Each user picks their own interface language.

csv · translationsen.csv
1key;de;en
2ui.save;Speichern;Save
3ui.cancel;Abbrechen;Cancel
4entity.artikel;Artikel;Article

translations/en.csv · import / export

Sorting, filtering and column selection

List views for large tables: pick the columns you need, filter, sort, page through.

LessHeadCMS list view for Article: 7 of 15 entries shown, a filter per column with the content column filtered for a search term, Reset filters and Columns (5/10) buttons, and Edit, Duplicate and Delete actions per row

Test data generator

Fill your model with plausible records to try list views, filters and permissions before real content exists.

LessHeadCMS test data generator: a count of 10 records each for Article, Category, Author and Tag, and a Generate button

Interfaces shown are actual screenshots from LessHeadCMS's backend.

§ 04 — Performance

Small footprint. Big tables.

Lightweight by design. Tested with real data.

What changed during development: every foreign key now gets an index automatically, and lists are paged, sorted and filtered in the database instead of being loaded completely into the browser. The figures compare the development version before and after these two changes.

List view
0.23s

List view with 1,000,000 records.

Delete
24ms

Deleting a record in a table containing 1,000,000 records.

Memory
4MB

PHP memory per list request, regardless of table size.

Concurrency
95%< 0.3 s

Response times with 100 editors working simultaneously at 1 action per second, with zero errors during the test.

Opening the list view table with 100,000 records · seconds
Loaded in the browser
48 s
Paged in the database
0.25 s
Deleting one record table with 1,000,000 records · seconds
Without index
1.1 s
With automatic index
24 ms

Measurements on a local PHP + SQLite test setup, using the same scripts and the same machine for the development version before and after optimisation. Text sorting across very large tables is slower, taking approximately 3 seconds with 1 million records.

§ 05 — Who it's for

One model. Three kinds of work.

The diagram is the shared language: code for developers, a workshop tool for agencies, a clear form for editors.

A REST API you can read in one sitting.

Every class in the model gets its endpoints. List responses are paginated and carry their own totals, so clients never guess.

REST API reference →
GET/api/articles?page=1&per_page=50&sort=title200 OK
"data"
"id" 1842
"title" "Adjusting cup-and-cone bearings"
"slug" "adjusting-cup-and-cone-bearings"
"language" "EN"
"written_by_author_id" 7
"translation_of_article_id" null
"id" 2310
"title" "Bleeding hydraulic disc brakes"
"slug" "bleeding-hydraulic-disc-brakes"
"language" "EN"
"written_by_author_id" 12
"translation_of_article_id" null
"total" 12345
"page" 1
"per_page" 50
"total_pages" 247
§ 06 — What you don't need

Everything you need. Less of everything else.

How LessHeadCMS is deployed and licensed, next to what some hosted alternatives may additionally require.

AspectLessHeadCMSTypical cloud-based headless CMS
Hosting requirementsPHP 8 and SQLite on ordinary shared hosting.Runs on the provider's platform; self-hosted editions may need their own runtime and database server.
Platform subscriptionNone. Free and open source under AGPL v3.Often billed per project, seat or usage tier.
Infrastructure and deploymentUpload via FTP or run composer. The database is one SQLite file.Managed by the provider, or a stack of services and build steps when self-hosted.
Dependence on a providerYour server, your database file, your code.Content, limits and API terms are set by the provider.
Editorial learning curveForms are generated from your model and show only its fields.A general-purpose interface, configured to fit the project.

See detailed comparisons →

§ 07 — FAQ

Questions, answered plainly.

What people usually ask before they install it.

01

Can I run a headless CMS on ordinary shared hosting?

Yes. LessHeadCMS is built for exactly that. It needs PHP 8 (but PHP 7.4 will do just fine) with SQLite (PDO), which most standard shared hosting packages already provide. There is no Node.js runtime, no Docker container and no root access involved: you upload the files via FTP or install them with Composer, and the CMS runs like any other PHP application.

02

Does LessHeadCMS need Node.js, Docker or a build step on the server?

No. The server side is plain PHP. The editorial interface ships as prebuilt static files, so nothing has to be compiled or kept running on your hosting.

03

How do I install LessHeadCMS?

Either run composer create-project elverdaderobutschito/lessheadcms or download the release, unpack it and upload it via FTP. On first start you set an administrator password; after that you load your content model and start editing.

04

How do I define content types without clicking through settings screens?

You describe your content model as a PlantUML class diagram: classes become content types, attributes become fields, and associations become relations. LessHeadCMS supports enums, required and unique fields, 1:1, 1:n and n:n relations, self-references and inheritance. From this one file it creates the database tables, the REST API and the editing forms.

05

What happens when my content model changes later?

You edit the diagram and LessHeadCMS shows you a diff of the schema changes before anything is applied. A database backup is written automatically before each migration, fields and classes can be renamed without losing data, and you are warned if a change would delete existing content.

06

Which database does LessHeadCMS use, and how much data can it handle?

LessHeadCMS stores everything in a single SQLite file. In our tests the list view opened in 0.23 seconds with 1,000,000 records, and 100 editors working simultaneously got 95% of responses in under 0.3 seconds without errors. These are measurements from a local test setup, not guaranteed for every hosting environment. A database abstraction layer is on the roadmap, so that you can later use a database of your liking.

07

What does the REST API look like?

Every content type in your model gets its own endpoints. List responses are paginated and include their totals (data, total, page, per_page, total_pages), and sorting, filtering and search run on the server, so frontends never have to load a whole table.

08

Is LessHeadCMS free for commercial projects?

Yes. LessHeadCMS is free and open source under the GNU AGPL v3, including for client and commercial projects. The AGPL requires that if you modify LessHeadCMS itself and make it available to users over a network, you share your modified source code. Hosting providers who need different terms can ask about a commercial licence.

09

Does LessHeadCMS include roles, permissions and editorial workflows?

Yes. Permissions can be set per role, group or individual user, down to single fields and actions. Approval workflows are defined as short text blocks: states, transitions, which groups may trigger them, who gets assigned and what happens on approval – for example, contributors submit and an editor-in-chief publishes.

10

Can I manage multilingual content?

Yes, through your content model: add a language field and a "translation of" relation to a content type, and each language version becomes its own linked record. There is no separate, hidden translation layer.

11

Can the editorial interface be shown in other languages?

Yes. All interface texts, as well as the names of your content types and fields, can be translated in the admin area. An English translation is included, further languages can be imported and exported as CSV files, and each user chooses their own interface language.

12

How does LessHeadCMS compare to Strapi or Directus?

Strapi and Directus are mature, Node.js-based platforms with large ecosystems, GraphQL and hosted cloud offerings. LessHeadCMS takes a narrower approach: plain PHP and SQLite on standard shared hosting, a REST API, and a content model defined as a diagram instead of in an admin UI. It suits projects where low hosting requirements and a simple, model-driven setup matter more than a large plugin ecosystem.

Less is a design decision.

Not every content system needs a platform, a cluster, and a pricing calculator.

Sometimes you need a model, a database, an API, and an editor that makes sense.

That should be enough to get started.

The headless CMS for the rest of us

Free. Open source. Yours.

composer create-project elverdaderobutschito/lessheadcms

AGPL v3. Commercial licensing for hosting providers on request.

Built by someone who's been around the web for a while.

Hi, I'm Butsch (don't laugh!). It's an abbreviation of my family name, invented by my maths teacher in 5th grade. Ever since I've been called "Butsch". If the first thing that pops up in your mind is "Butch Cassidy and the Sundance Kid", you're probably my age. …

More about the person behind LessHeadCMS →