Why Use a Headless CMS as an Internal Tool?
Tags: headlesscms, headless, cms
Published: 2021-12-13 16:02:12

Imagine a brand-new website. The developer who creates it is great at HTML. They are given some content and diligently add it, handcrafting every  `<div>`  to say exactly what’s needed. The next person who wants to create content for the site is a marketing genius and can write compelling copy, but they have no experience with HTML. How does an organization make sure both individuals can effectively create content without the reader immediately noticing a difference in style?

Enter the content management system (CMS). A CMS is a method of standardizing content creation, content indexing, and content styling for multiple individuals with different specialties across an organization. A CMS normally implements some kind of authentication, stores documents and images, and standardizes the HTML output for regular types of content updates, like a blog post or a quarterly report. CMSs also index content, so it’s simple to revisit content that requires updates or reorganization.

In this article, you will learn more about the increasing popularity of headless CMSs and examine several great ways to use them internally.

## What Makes a CMS Headless?

Before there were CMSs, there was File Transfer Protocol (FTP), which allows users to directly upload files to their server. This requires a lot of technical knowledge and the willingness to test before deploying. If someone wrote broken HTML, broken HTML was going into the application.

GeoCities was one of the first web-based CMSs. Like most CMS platforms for the next two decades, the CMS was fused to the deployment platform. Things that were written using the GeoCities CMS were used to deploy pages on the GeoCities platform. Eventually, open-source options, like [WordPress](https://wordpress.com/) and [Drupal](https://www.drupal.org/) overran the web. Those CMSs were self-hosted—meaning the user could bring the CMS platform onto their own server and express a higher degree of control over it. However, if you were using a WordPress CMS, the content produced by the CMS was normally used in a webpage also created by WordPress. In other words, any content created on a CMS platform was also delivered to users using the same platform.

Headless CMSs, on the other hand, break apart the connection between the platform used to create content and the platform used to view content. Instead of using a platform like WordPress to create and publish content, you can use a headless CMS like [Strapi](https://strapi.io/) to create content then deliver that content using whatever platform is most convenient.

## Why Make CMS Headless?

What motivated this shift away from putting the content creation and content delivery on the same platform? One of the largest reasons is the increasing range of devices that access the internet. WordPress content simply isn’t designed to be displayed on an internet-accessible thermostat, but that device still needs content updates. Even something as simple as serving slightly different desktop and mobile websites can be heavily optimized by using different technologies to serve the content.

This distinction between content creation and content distribution is particularly important as cloud computing becomes more popular. Coupled CMSs, like WordPress, are challenging to optimize. When accepting a particular content distribution system for the benefit of using a familiar content creation system, the trade-off becomes larger the more requests an application or website manages. When using cloud computing, clients pay for network usage, storage, and CPU. Common load reduction techniques, like server-side rendering and default image sizing, are possible with coupled CMSs, but they can be hard to implement if they weren’t a top-of-mind concern when the CMS was created.

Headless CMSs allow content to be distributed across multiple channels, languages, and devices. They make it simple to introduce cost-saving measures at scale by allowing developers to add and modify features for content distribution by using a language and deployment system that closely fits their use case.

## Common Headless CMS Features

So why are headless CMSs growing in popularity? Most use one of the more modern JavaScript frameworks, like React or Next.js (Strapi users can use either), to generate the form used to add content. These JavaScript frameworks have made it much simpler for developers to duplicate the consistency of coupled CMSs using only the browser.

Headless CMSs are also generally conceptualized as APIs. JavaScript browser frameworks provide the frontend for the data upload, but for data retrieval to work across devices, there needs to be a standardized way to access that data. Thus, many headless CMSs provide an API for data retrieval. With Strapi, data can be accessed with [REST](https://strapi.io/documentation/developer-docs/latest/developer-resources/content-api/content-api.html#api-endpoints) or [GraphQL](https://strapi.io/documentation/developer-docs/latest/development/plugins/graphql.html#graphql) requests, making it simple for any type of device or application to retrieve the data it needs.

![Comparing CMS architectures](/uploads/y9d_Wn_Hi_3b87a553bc.jpg)

## The Cost of a Headless CMS: Careful Planning

Headless CMS platforms do require some up-front planning and development. The benefit of divorcing content creation and content distribution can be a double-edged sword. Changes to the content creation branch of an application don’t automatically appear in the content display branch. With a coupled CMS platform, when you change the input fields for a blog post, the display of the blog post will also automatically change. With a headless CMS, users will have to be more active when making changes to how content is created. New fields in the CMS will have to be manually added to the distribution platform.

This trade-off can be easily mitigated by using an established headless CMS platform with a proven record of working for and with businesses. Strapi works hard to make planning content easy and make changing content simple with drag-and-drop sections, order management, and custom plug-ins.

## When to Use a Headless CMS

There are a variety of scenarios in which using a headless CMS could be beneficial. Take a look at a few here:

### Simplifying Your Backend

One of the best parts of using a headless CMS—and particularly a headless CMS like Strapi that stores content in the cloud rather than on a local server—is the ability to significantly reduce the amount of backend architecture any application needs. Databases in coupled CMSs perform double duty. They hold vital information about your business, and they store information that is used for generating content.

By introducing a headless CMS, your database is freed from half of that obligation and can focus on holding vital customer information. The CMS stores most of the information used for creating content. This means it’s much simpler to deploy pre-rendered applications that request the data they need at the last moment, saving on network costs, database maintenance, and overhead.

### Breaking Up a Monolith

Headless CMSs make it easier to create a more modular backend. This also makes it easier to have more modular frontend services. It’s easier to split up applications because each tool is able to implement access to a shared pool of data using whatever language is best suited for that service.

### Using It for Internal Tools

The benefits of a headless CMS are extremely well suited for internal tools. Internal tools help regulate the course of a business, have requirements that change over time, can be used by multiple stakeholders, and ideally cost very little to implement and deploy.

Strapi makes it possible to put internal tools in static HTML sites, allowing them to be quickly and cheaply deployed. Removing the overhead of setting up a database allows internal tools to become more flexible. It’s a smaller task to add new fields and use them. This drives down development costs and makes it easier to justify updating internal tools to keep up with the requirements of the teams using them.

The flexibility of data access is also a great benefit for internal tools. If marketing needs a piece of the data generated by the research team, that data can be quite simply made available to the users who need it by adding an API call to whatever tool the marketing team is already using.

This modular design doesn’t just make it simpler to spread data around; it’s also much simpler to implement access control using a headless CMS. In a monolithic system, developers have to reason about and develop access controls around who gets to access what data. With a headless CMS, internal tools can easily share a pool of data, but it’s much simpler to limit access to that data by restricting the API calls any given tool is making.

Finally, internal tools often already exist in one form or another. Headless CMSs are ideal for slotting into existing tools while being used to support the development of newer tools. The ability to share data between these systems removes the need to develop completely different systems for newly discovered requirements. New tools can use whatever language is most convenient or best suited for the task at hand, rather than being locked into a legacy system that may not fit the requirements simply because they need to interact with existing systems.

## Fitting In A Headless CMS

Headless CMSs like Strapi have been used to power a [wide variety](https://strapi.io/user-stories]) of real-world applications. They are a perfect fit for any application that requires rapid content generation from a variety of sources. That might be fast application development where the [content generation is handled by a client](https://strapi.io/user-stories/zero-molecule), generation of [SEO optimized content](https://strapi.io/user-stories/finary) handled by a rotating cast of experts, or an [ecommerce marketplace with a flexible suite](https://strapi.io/user-stories/ae-studio-prosperity) of products and stakeholders. 

![undefined - Imgur.png](/uploads/undefined_Imgur_1026d2ce67.png)

Another great use case for a headless CMS is an internal training platform. The process of deciding how to train employees is a challenging task to formalize, and it makes a huge difference for how supported and effective new employees feel. 

The flexibility and speed of deployment in a headless CMS allows for rapid iterations on training methodology, so it can evolve with feedback from every new employee. Every member of a team will have some unique perspective about how to best prepare people for a new role, so the ability to democratize content creation can pay huge and unexpected dividends. 

![Headless CMS training diagram](/uploads/Kj_R_Rn_XN_2_acca12e2db.png)

The ability to easily tap into existing data sources allows new employees to work with a graduated system of knowledge. They can be introduced to the real data that is most vital for their role before being given full access to production quality data.

In each of these cases, passing data into an API like Strapi allows rapid application development, easy-to-manage authentication, simple and reusable configuration, and no backend maintenance. It’s simple and fast to iterate with a wide range of content requirements.

## The Future of Headless CMS

In this article, you learned about what makes a CMS headless and what the benefits and costs are of using a headless CMS. Headless CMSs are here to stay; they allow developers to create a standard interface for creating content, they are extremely flexible about how that data is accessed and used, and they significantly reduce the overhead of modifying the content creation process. These features are often a great match for internal tools that are initially created by developers but then need to be managed by a range of individuals.

[Strapi](https://strapi.io/) has built a simple, modular headless CMS. It’s ideal for getting systems up and running quickly. No matter what language and architecture your system use, the Strapi headless CMS can help you create and standardize compelling content.