A cloud-native CMS assumes that any server can disappear at any moment. When that happens, editors stay logged in, uploads are still there and visitors notice nothing. Everything else follows from this: the application runs as identical, replaceable instances and keeps its state in services outside of them.

Many products are called cloud-native because they run on AWS or offer an API. Neither says much. WordPress on an EC2 instance is still WordPress on a single server, only rented from Amazon.

The CNCF definition talks about scalable, resilient, observable and loosely coupled systems. Below, I translate that into eight concrete requirements for a CMS, list the features that are often mixed up with them, and compare hosted and self-hosted setups.

The eight requirements

If a CMS misses one of these, it's a traditional CMS that happens to run in the cloud.

  1. Stateless instances. It doesn't matter which instance answers a request. Sessions, shared caches and locks are stored in Redis or the database. Purely local speed-ups like OPcache or compiled templates are fine, as long as no other instance depends on them.
  2. Object storage for files. Uploads go to S3, Azure Blob, Google Cloud Storage or a compatible service instead of a local uploads/ folder. The same applies to generated files such as thumbnails, resized images and exports, which are easy to forget. A fresh instance with an empty disk must be able to serve every file.
  3. Horizontal scaling. You handle more traffic by adding instances behind a load balancer rather than buying a bigger server. That only works if the first two points hold. Adding instances automatically is a separate step and not required.
  4. Cluster-safe background work. A scheduled task runs once per schedule, regardless of how many instances are up, either through a single scheduler or a distributed lock. Slow jobs go into a queue processed by separate workers.
  5. Configuration from the environment. Credentials, endpoints and feature flags are read from environment variables or a secrets manager, as described in the 12-factor app. The same build runs in development, staging and production.
  6. Automated deployments. CI/CD ships container images or immutable bundles. Nobody logs into a server to change files or install plugins, and rolling back means deploying the previous image. Database migrations run once per release, as their own deploy step or under a lock (in Laravel: php artisan migrate --isolated), and never from every instance at startup.
  7. Health checks. Each instance has an endpoint the orchestrator can probe, so a broken instance is removed and replaced without waking anyone up.
  8. Logs as streams. Logs go to stdout or a log service. Log files inside a container disappear with it.

I'll use PagibleAI, an MIT-licensed CMS package for Laravel, as the example here. It relies on Laravel's filesystem, cache, queue and logging abstractions, so most of this is configuration rather than code. Requirements 1, 2, 4, 5 and 8 look like this in the .env file:

# credentials via IAM role, or AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY FILESYSTEM_DISK=s3 AWS_BUCKET=cms-media AWS_DEFAULT_REGION=eu-central-1 REDIS_HOST=redis.internal SESSION_DRIVER=redis CACHE_STORE=redis QUEUE_CONNECTION=redis LOG_CHANNEL=stderr 

Scheduled tasks that must not overlap get ->onOneServer(), which takes a lock in the shared cache.

Laravel also ships an /up route for health checks, which PagibleAI inherits. By default it only confirms that the app boots. To include the database or Redis, listen for the DiagnosingHealth event and throw an exception if a dependency is unreachable. Use such a check for readiness only: if the database goes down, Kubernetes should stop sending traffic, not restart every pod.

The examples assume the container serves HTTP itself on port 8080, for example with FrankenPHP, Octane or nginx in front of PHP-FPM. PHP-FPM alone doesn't speak HTTP. In Kubernetes you point the probes at the route:

readinessProbe: httpGet: path: /up port: 8080 periodSeconds: 10 livenessProbe: httpGet: path: /up port: 8080 initialDelaySeconds: 20 

Without Kubernetes, a Docker health check does the same for Compose, Swarm and most container platforms (the image needs curl installed):

HEALTHCHECK --interval=10s --timeout=3s CMD curl -fsS http://localhost:8080/up || exit 1 

Other stacks have the same building blocks. Strapi and Payload use upload providers or storage adapters for S3 and can keep sessions and cache in Redis, and most Go and Python systems read these settings from the environment. Check that your CMS supports them out of the box and doesn't silently write to local disk somewhere.

Optional features

The following features show up in many cloud-native systems and often get treated as part of the definition. They are useful in the right situation, but a CMS can meet all eight requirements without any of them.

Feature Useful when
Headless API (REST, GraphQL) Websites, apps or kiosks share the same content
Server-rendered pages You want a website without building a separate frontend
CDN and edge caching Visitors are spread around the world or traffic comes in spikes
Autoscaling Load varies a lot during the day or the year
Serverless Traffic is low or very bursty and you want to pay per request
Kubernetes You already run a cluster (for a single site it's usually overkill)
Multiple regions You have strict uptime targets or data-residency rules
Multi-tenancy One installation serves many sites or customers
Realtime collaboration Several editors work on the same pages at once
Audit logs and metrics Compliance requires it or the editorial team is large
AI and agent access (e.g. MCP) You produce or translate a lot of content

Headless is the one most often confused with cloud-native. Headless describes how content gets to the frontend. Cloud-native describes how the system is run. A headless CMS may still depend on a single server, and a cloud-native CMS can render plain HTML. PagibleAI does both from the same content model: server-rendered Blade themes for websites, a read-only JSON:API for apps and static-site builds, and a GraphQL API for the editor and custom tools.

Cloud-native vs. traditional CMS

The main difference is where state is kept. A classic WordPress, Joomla or Drupal installation stores code, uploads, cache and sessions on the disk of one server. A cloud-native CMS keeps none of that on the instance.

Traditional CMS keeps code, uploads, cache, logs and database on one server; a cloud-native CMS runs disposable instances behind a load balancer, with all state in shared managed services

If the server on the left fails, everything on it is gone until it's restored. On the right, an instance can be replaced at any time because nothing on it has to survive.

Aspect Traditional Cloud-native
Deployment unit One long-lived server Identical instances built from one image
Scaling Bigger server More instances
Server failure Site down until repaired Traffic goes to other instances, the broken one is replaced
Updates In place, via admin UI or FTP New image, rollback by redeploying the old one
Extensions Installed on the live server Added at build time
Configuration Files on the server Environment variables, secrets manager
Cost Low and fixed for small sites Grows with usage, more services to run

The traditional setup still has its place. For a single site with modest traffic, one well-maintained server is simpler and cheaper than a set of managed services. The cloud-native approach starts to pay off with traffic spikes, uptime targets, many sites, or teams that want every change to go through review and CI.

Moving a traditional CMS into the cloud rarely makes it cloud-native. Plugins that write to the local disk, cron jobs that expect a single server and updates through the admin panel all cause trouble once a second instance exists. Teams usually work around this with offload plugins, a shared file system like NFS or EFS and a rule against installing plugins in production. That works, but every workaround needs maintenance.

Hosted or self-hosted

Whether a CMS is cloud-native and who runs it are two separate questions. The same architecture is available as a service or as software you deploy yourself, and that choice affects cost and risk more than most features do.

With a hosted CMS, the vendor runs a multi-tenant service and you get an editor and an API. Contentful, Sanity, Storyblok and Contentstack work this way. With a self-hosted CMS, you deploy the software to infrastructure you control, such as AWS, Azure, Google Cloud, a European provider or your own Kubernetes cluster. Strapi, Payload, Directus and PagibleAI are in this group. PagibleAI is built for the integration case: it installs with composer require aimeos/pagible into an existing Laravel application and shares its database, login and deployment pipeline instead of running as a separate service.

Aspect Hosted Self-hosted
Operations Done by the vendor Done by your team or an agency
Time to first content Minutes Hours to days
Pricing Usually by seats, locales, API calls or records Infrastructure plus staff time
Data location The vendor's regions Any region or provider
Customization Vendor's extension points and webhooks Full access to the source
Integration with your app Through the API Can share code, database and login
Limits Plan quotas and rate limits Your infrastructure
Lock-in Proprietary content model and API Usually open source, data in your own database
Security Shared with the vendor Yours, on top of the provider's infrastructure

Quotas and the tiers that include regional data hosting differ a lot between vendors and change often, so check the current pricing pages.

Hosted is the better fit if you have nobody to run infrastructure, need to launch quickly and the plan limits will cover your growth for the next few years. Self-hosting makes more sense if compliance rules decide where your data lives, if the CMS has to be tightly integrated with an existing application, if usage-based pricing would outgrow your budget, or if you need to change how the system behaves in code.

There is also a mix of both: self-hostable software that the vendor or a hosting partner runs for you. You start with the convenience of a hosted service and can take over operations later without migrating your content.

Checking a "cloud-native" claim

These questions help with any vendor or project. If the answer to one of the first seven is no, the system runs in the cloud but isn't cloud-native.

  1. Can I stop any running instance under load without users losing their session or uploads?
  2. Do files go directly to object storage, without a shared network file system?
  3. Can I run three instances behind a load balancer without sticky sessions?
  4. Does each scheduled task run once, no matter how many instances are up?
  5. Are all settings and secrets passed in through the environment?
  6. Are extensions and the content model part of the build, and do migrations run once per release?
  7. Is there a health check endpoint, and do logs go to stdout or a log service?
  8. For hosted products: can I export all content and files in an open format?

You can try the first question in a few minutes with Docker Compose, as long as a reverse proxy sits in front of the app service:

docker compose up -d --scale app=3 # log in to the admin, upload an image, then stop one replica docker stop $(docker compose ps -q app | head -n 1) # reload the admin: still logged in, image still there? 

If you were logged out or the image is missing, state is stored on the instance.

This only tells you something if uploads go to object storage. A shared Docker volume makes a single-server setup pass as well, and that doesn't help you once instances run on different hosts.

Conclusion

A cloud-native CMS costs a bit more effort upfront and gives you resilience, scaling and repeatable releases in return. Whether you buy it as a service or run it yourself depends on your operations capacity, how costs grow with usage, where your data has to live and how much control you need over the code.

How many of the checks does your current CMS pass? If you want to see how a CMS supports these requirements in code, the PagibleAI source is a good starting point.