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. This often means that developers reach for opinionated systems that come with these features out of the box. However, sometimes that interferes too much with the quality of output we are targeting. Or it just takes so much time to work with the system's preferred (or only) ways of achieving what we need that developers find it more economical and sustainable to convince their clients not to make a CMS a required feature.
But maybe some of these unconventional approaches can bridge the gap for some 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 utilizes 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 side. In the end, it results in some JSON that can be handled like any other JSON.
There is one caveat here: 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. However, that doesn't mean there are no workarounds - this depends on your setup. API requests could still be made from the Edge or with some form of serverless approach.
One way to approach this could be to only fetch from the API during 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 the same reasons can be applied to Dropbox Paper. Just like using Google Docs as a CMS, it comes with a visual interface built on collaborative features. Commenting and versioning are built in. Plus, Dropbox Paper also supports markdown, which is great for a headless CMS approach. Markup is often context-dependent, and it's a bit easier to parse markdown instead of fully rendered HTML to apply some context-specific changes.
One drawback of this approach is that Dropbox Paper does not communicate content updates via its API. This means that publishing new or updated content in Dropbox Paper still requires some manual triggering of the system that pulls in content from its API. However, this may be an easy limitation to work 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 content. Users love its database features, the editing experience, and its ability to reuse the same content in various ways.
Ever since the release of its API in 2021, Notion enthusiasts have been utilizing it for all sorts of purposes. The web is full of content on this topic. So instead of spending too much time on some 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 tend to integrate into an organization and stay there. In stark contrast to other popular tools like Confluence or Obsidian, Notion provides a less painful way to use its API to display content elsewhere. So it might be worth considering!
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 strange at first. But there's some elegance to it. It's not too far-fetched to see how existing document management solutions 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 with all the other systems, collaboration is built 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 organization. This way, multiple people from various professions are already familiar with its logical premises 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 like 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. However, it requires relatively little effort to 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 webhooks that trigger whenever a board, list, or card changes. This makes it not only easy to cache but also means that updating content does not 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 utilizing 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 extent, but they sometimes severely impact how we develop. However, sometimes all you need is some simple editing and updating of a piece of content, not necessarily the ability to create entire pages. In these cases, considering some of those more unusual approaches for managing content may be exactly what is right! And who knows what other unconventional ways to manage content are still out there? Maybe you are even inspired to invent your own!