Unconventional CMS'ing

Clients want their content editable. But often, allowing them to make simple edits on a website, requires a whole lot of other stuff. And that often means, that developers reach for opinionated systems, that come with these things out of the box. But sometimes, that interferes too much with the quality of output that we are targeting. Or it just requires so much time, to work with the system's preferred (or only) ways of achieving what we need to, that developers find it more economic and more sustainable, to convince their clients to not make a CMS a required feature.

But maybe, some of these unconventional approaches can close the gap for some of these projects, allowing you or your clients to edit content more easily, or more frequently.

Google Drive

This is a fantastic approach for a wide variety of use cases. From simple blogging, to managing product listings and more. This approach essentially utilises Google Drive as cloud storage, with google sheets as a UI on top of it. It mostly requires some wiring and work on the integration part. In the end, what it results in is some JSON that can be handled in whatever way one would handle any other JSON.

There is one caveat here, which is that the API requests to the Google Drive API have to be made from node, to keep the authentication credentials safe, so direct client-side API requests are not possible. Though that doesn't mean that there are no ways around this - this depends on your setup. API Requests could still be made from the Edge or with some form of serverless approach.

One way to go about this, could be to only fetch from the API in the build step, if you are statically generating your site, for example with eleventy. Another important factor to work around is Google Drive's API Rate Limit of 300 Requests per minute, by implementing caching strategies.

More about this:

• https://www.drivecms.xyz/

• https://css-tricks.com/creating-an-editable-site-with-google-sheets-and-eleventy/

• https://css-tricks.com/creating-an-editable-webpage-with-google-spreadsheets-and-tabletop-js/

• https://css-tricks.com/using-google-drive-as-a-cms/

Dropbox Paper

A similar approach for identical reasons can be applied to Dropbox Paper. Just as is true for using Google Docs as a CMS, it comes with a visual interface that is built upon collaborative features. Commenting and versioning is built in. Plus, Dropbox Paper also supports markdown, which is great for a headless CMS approach. Markup is often subject to the context in which it is used, and it is a bit easier to parse markdown instead of fully rendered HTML, to apply some context-specific changes to it.

One drawback of this approach is that Dropbox Paper does not communicate content updates via its API. Meaning, that publishing new or updated content published in Dropbox Paper still requires some manual triggering of the system that pulls in content from its API. But that may be an easy limitation to develop around, depending on what you are trying to achieve.

More about this:

• https://www.voorhoede.nl/en/blog/dropbox-paper-as-a-headless-cms/

• https://www.dropbox.com/developers/documentation/http/documentation#paper

Notion

Notion is an incredibly popular System for managing knowledge and also content. Users love its database features, the editing experience and its ability to reuse one and the same content in varying ways.

Ever since the release of its API in 2021, lovers of Notion have been utilising it for all sorts of purposes. The web is full of content regarding this topic. So instead of spending too much time on some of the details, we'll just leave you with some further links.

Much of this solution may depend on how familiar your clients already are with notion. Knowledge management apps have a tendency to hook into an organisation and remain there. In stark comparison to other popular tools for this, like Confluence or Obsidian, notion provides a not-so-painful way to make use of its API to show its content somewhere else. So it might be worth your consideration!

More about this:

• https://www.thisdot.co/blog/using-notion-as-a-cms

• https://benborgers.com/posts/notion-blog

• YouTube Playlist: https://www.youtube.com/watch?v=mukkm6o6Pjw&list=PLoqZcxvpWzzdJiW95Y7nDqY8XsiKTgo17

• Portfolio with Next & Notion: https://www.youtube.com/watch?v=04exSpZ9IZ8

Github Issues & Trello

Now this one might be a bit unexpected and feel weird at first. But there's some elegance to it. It's not too far of a stretch, to see how existing solutions to manage documents can also be used for managing content on a website, but moving things on lanes? That may take a bit to settle in. But it's possible!

As was true with all of the other systems, collaboration is baked in, should you want it. But even more so on Trello and Github. The big plus here is that both tools sometimes serve as a source of truth for the progress in a project or organisation. That way, multiple people from multiple professions are already familiar with its logical premisses and models.

Github

Github has a GraphQL API that can be used to query issues easily. Its contents are markdown and it offers built in taxonomies via its labels. Just as all the other approaches, it requires setting up a token for authentication.

This approach is a bit more developer friendly. It doesn't offer a visual interface, so knowledge of markdown is essential. But it requires relatively little effort to get query content and thus might be a good fit for some smaller, specific use cases.

More about this:

• https://dev.to/muhajirdev/using-github-issue-as-cms-2de1

• https://github.com/renatorib/github-blog

• https://www.sykim.me/blog/github-issues-as-cms

Trello

The Trello API allows querying boards, lists and cards and their status. The exciting part is the addition of web hooks that fire whenever a board, a list or a card changes. This makes it not only easy to cache but also means that updating content does require any in-between-steps, because even for statically generated sites, a rebuild can be triggered by changing a piece of content, for example, by observing a dedicated lane, or watching a card for a specific status change.

More about this:

• https://changelog.com/posts/trello-as-a-cms

• https://github.com/unplatform/husky-cms

• https://developer.atlassian.com/cloud/trello/guides/rest-api/api-introduction/#your-first-api-call

• https://medium.com/@vrerabek/using-trello-as-cms-for-your-small-website-with-this-simple-php-library-f03c641c6ccd

There are some even more unusual approaches. One company uses Figma as a CMS for static assets and someone explored options for utilising Tumblr as a CMS.

As developers, we are used to thinking of CMS as rigid systems, that allow us and our clients to operate autonomously to a much greater extend, but they sometimes severely impact how we develop. But sometimes, all you need it some simple editing and updating of a piece of content, not necessarily the ability to create entire pages. And in these cases, considering some of those more unusual approaches for managing content, may be exactly what it's right! And who knows, what other unconventional ways to manage content are still out there? Maybe you are even inspired, to invent your own!