Declarative CMS: The better way to develop digital experiences

There are currently hundreds, if not thousands of content management systems on the market and it is overwhelming to choose a new system for a project. You could keep building with the technology you currently use, but this comes at the expense of missing out on the technological advances that are currently happening at a rapid pace.

When you analyze the most popular content management solutions in more detail and on a first-principles basis, you quickly notice that they all share some serious flaws that can only be solved by taking a fundamentally different approach. Even the most basic modern software development workflows are surprisingly difficult or impossible to execute with most of the existing solutions.

A few examples:

• How do you do a code review on a change of a data model? In most cases, this has to happen outside of the codebase - if it happens at all.
• How do you develop something in isolation on a feature branch and then later merge it into the production environment? If you are lucky, you have one dedicated development environment where dozens of developers change things all over the place.
• How easy is it to integrate external software? In a lot of cases, you need to write a significant amount of custom code that requires a deep understanding of the CMS technology.
• How do you reuse functionality or data structures from one project in another? This almost always requires a rewrite or recreation with dozens of clicks.
• How can you see who changed what in a data model for what reasons at what time? A commit-history is oftentimes non-existent where you can link to external issue trackers and project management systems.
• How do you replicate an environment for local development or to launch similar projects fast? Oftentimes you end up having to do an extensive manual setup that is error-prone and requires documentation.
• How long does it take an experienced developer to be productive with your CMS, when she has never worked with it before? It is not uncommon to find job advertisements that ask for 3+ years of experience with a specific CMS, dramatically limiting the size of the already scarce talent pool.
• How do you apply or revert changes to your CMS in bulk, for example, to add or remove a more complex piece of functionality? Most of the time this requires remembering all the steps and then executing dozens of clicks and commands in reverse order.
• How do you scale your CMS for traffic spikes, if one machine is not sufficient anymore and you have to deploy your website with multiple replicas behind a load balancer? With some legacy systems, especially the ones that manage the dynamic application structure via file storage, you have to resort to vertical scaling or spend significant time setting up a complex cloud deployment.
• How do you prevent hacking attempts that stem from the fact that you have to grant your CMS write permissions on the file system? It is really easy to overlook something in the extensive setup instructions that can cause a hostile system takeover.
• etc.

This is why we built Slicknode!

The declarative CMS to the rescue

To solve these problems, we created Slicknode with a few goals in mind:

• All structural changes like data model updates and changes to exposed APIs have to happen in your local codebase to be able to leverage proper version control tools (git), continuous integration, etc.
• The infrastructure where the system is deployed needs to be entirely decoupled from the structure and allow for horizontal scaling
• A modular architecture from the core to manage complex systems and allow the reuse of functionality
• Onboarding of developers in minutes
• Seamless integration with existing systems with minimal effort

The result is a platform that is extremely easy to use and solves all of the problems that are listed above. To create a CMS with Slicknode, you simply define your data model in a declarative way with the GraphQL schema definition language. All the code and configuration lives in your codebase and can properly be managed with a version control system like git. This allows you to merge, reuse, copy & paste code and do everything else with your codebase that you are used to as a developer.

The data structure is pretty much self-explanatory for any skilled developer, regardless of background:

type Blog_Blog implements Node {
  id: ID!
  image: Image
  title: String!
  text: String! @input(type: MARKDOWN)
  author: User!
  comments: [Blog_Post!]!
}

To update your CMS, you simply deploy your local changes to the cloud. Slicknode compares your local state to the deployed version, automatically applies all database migrations, updates the CMS user interface based on your data model and provisions the resources in the highly scalable cloud environment:

slicknode deploy

This not only lets you iterate on your software at unparalleled speed, but you can also create a duplicate of a version of your software with a single command:

slicknode deploy --env feature-branch-test

The result is a comprehensive GraphQL API that you can use as a headless CMS to deliver content of any digital product to any digital channel (IoT, mobile, desktop etc.). Thanks to GraphQL you can load all the data you need in a single request, which can significantly reduce the complexity in your frontend applications. The open source protocol also ensures the seamless integration into the rest of the GraphQL ecosystem and compatibility to all the tools developers know and love (React, Vue, iOS etc.).

During the deployment process, a new immutable version of a container is launched and the traffic is switched over to the new containers. This also reduces the attack surface as the CMS can be deployed with read-only file permissions and with limited database access at the container level.

You can easily scale up the resources when you are ready to grow:

slicknode scale --api 5

Try it for yourself and check out the 5 min quickstart.