Architected for Scale: Managing 1000s of Sites and Users with CrafterCMS

Agencies and large enterprises with websites that number in the thousands, with hundreds of content authors, can’t simply rely on just any CMS. It’s why many enterprises still use legacy CMSs and DXPs from vendors like Sitecore, Adobe, OpenText and others to manage their across multiple sites.

Unfortunately, these legacy systems come with other problems that restrict scalability, impact performance, and limit innovation. These issues can become headaches for developers and content teams working with these tools, leading to subpar digital experiences for end users. 

One alternative is to use a headless CMS, but not every headless CMS offers the same ability to solve these scalability challenges. 

In this blog post, we explore the challenges of building and maintaining thousands of enterprise websites and users with legacy platforms, how a headless CMS typically handles these challenges, and how CrafterCMS overcomes the limitations of a standard headless CMS.

The Problem with Using Monolithic CMSs at Scale

Enterprises often stay on a monolithic CMS or DXP longer than they need to. Sooner or later, this leads to several problems that might seem small or easy to live with at first but can quickly cascade. 

For example, traditional monolithic CMS platforms were designed for one or a few digital experiences managed by a limited number of content authors. As enterprise or agency content operations grow to support thousands of microsites, regional websites, and hundreds of internal users, the limitations of monolithic CMS architectures become painfully apparent.

1. Tight Coupling of Frontend, Backend, and Database

In a monolithic CMS, all services such as UI, authoring tools, content repository, and delivery, are tightly integrated. This coupling makes it difficult to scale individual components independently. When you need to support thousands of websites or hundreds of active authors, the entire monolith must scale together, leading to resource contention, performance bottlenecks, and limited deployment flexibility.

2. Global Bottlenecks in Authoring and Publishing

With hundreds of users sharing a single, centralized backend, operations like publishing, preview generation, and workflow orchestration become bottlenecks. A spike in publishing activity from one team can impact others. Monolithic CMSs often lack isolation between sites or teams, causing cross-site latency and UI slowdowns.

3. Lack of Multi-Tenancy or Logical Site Isolation

Scaling to 1,000+ sites requires logical separation—both for content governance and system stability. Most monoliths treat sites as just folders in a tree or branches in a hierarchy, without true multi-site awareness or tenant-level permissions. This results in fragile content structures, complex permissioning, and higher risk of accidental content leakage or admin errors.

4. Rigid Infrastructure and DevOps Overhead

Monolithic CMSs are typically not cloud-native and require vertical scaling (bigger servers) rather than horizontal scaling (more instances). Managing deployments, versioning, and CI/CD pipelines across many sites becomes error-prone. Dev teams are forced to work around limitations with brittle scripting, cron jobs, or duplicate instances—none of which scale cleanly.

5. Poor Fit for Distributed and Composable Architectures

Modern enterprises demand composable architectures, where different teams can innovate independently using APIs, micro frontends, and best-of-breed tools. Monolithic CMSs were never built with this in mind, and their inflexible architectures block integration with modern DevOps, AI content workflows, and multi-channel delivery systems.

6. Performance

A knock-on effect of the scalability challenges associated with legacy CMSs is the performance bottleneck it creates. Over time, these platforms are prone to slower loading times and glitches due to outdated architecture. These performance issues can hamper the user experience and make delivering content to multiple channels and websites even harder. 

7. High Licensing and Maintenance Costs

Legacy CMSs and DXPs already have high total cost of ownership costs for enterprises with just a single website. With thousands of websites and authors to manage, as well as increasing annual costs for maintenance and security needs, enterprises can often struggle to get a positive return on investment. 

Why Most Headless CMSs Struggle to Solve These Challenges 

Headless CMSs that separate the frontend presentation layer from the backend content repository offer the flexibility and scalability that most businesses currently using a legacy CMS would welcome. 

However, there are also many issues that prevent most headless CMSs from solving the challenges faced by large scale enterprises with hundreds or thousands of websites. 

• Database-Oriented: Most headless CMSs are database-centric, built on SQL or NoSQL databases to manage content. This reliance on centralized databases restricts how content gets stored and delivered and doesn’t align with the modern Git and CI/CD processes that developers are accustomed to. Moreover, scaling the delivery system becomes a database scaling nightmare.
• Simple Content Authoring: Many pure headless CMSs lack key content authoring capabilities like drag-and-drop editing and content previews. However, content authors coming from traditional or legacy platforms will expect these features.
• Lack of Hosting Options: Many headless CMSs are only available as publicly-shared SaaS options with opaque cloud hosting (i.e., no control over deployment across geographic regions). While this provides a number of advantages, it also limits businesses (particularly those coming from on-premise hosting) that need more flexible hosting options due to being in regulated industries. 

To avoid these problems large-scale enterprises should look for a headless CMS that meets the following criteria:

• Git-based Content Repository: A Git-based CMS uses a decentralized Git repository and works with files stored in the repository to manage content, improve content versioning and tracking, and allow for easier collaboration between content and developer teams. 
• Authoring Friendly: Provides the traditional authoring features content authors need, including drag/drop experience building, WYSIWYG content editing, and multi-channel preview. 
• Stateless/Serverless Content Delivery: A scalable CMS should operate in a stateless/serverless fashion with need no database required at runtime. This eliminates the traditional bottlenecks associated with relational data stores, enables near-instant boot times, simplified deployment, and highly elastic scalability across cloud. A stateless architecture allows multiple delivery instances to run independently and horizontally scale on demand, making it ideal for high-traffic scenarios and distributed delivery. 
• Multiple Hosting Options: Offers not only SaaS hosting but also private, secure SaaS and self-hosted/self-managed options for enterprises that need it. 

How CrafterCMS Supports Large-Scale Website Management

CrafterCMS enables enterprises and agencies to manage large numbers of websites and digital experiences using its Git-based content repository, decoupled  architecture, and stateless/serverless horizontally-scalable content delivery system.

Managing Large Numbers of CMS Projects

One of the key advantages of CrafterCMS for enterprise-scale content operations is its ability to manage large numbers of sites and projects in a clean, modular, and scalable way. At the core of this approach is CrafterCMS’s Git-based architecture: every site or CMS project is represented as its own Git repository. This provides not only a clear boundary between projects, but also brings the full power of version control, portability, and automation to site management.

With each project encapsulated in its own Git repo, organizations can easily spin up new sites, clone existing ones, or retire and archive older instances as needed, and without impacting other parts of the system. This is particularly valuable for enterprises that operate hundreds or thousands of localized websites, microsites, campaign sites, brand variants, or internal portals. New sites can inherit baseline templates and content from existing ones, allowing for rapid provisioning and consistent branding.

Because sites are isolated at the repository level, they can be developed, deployed, and governed independently. Teams working on one site aren’t affected by workflow changes, authoring roles, or publishing events from another. While content structure and assets can be cloned during site creation, user assignments, workflow states, and author interactions are deliberately not copied—preserving clean separation of governance and enabling site-specific customization of permissions and editorial workflows.

This model is a sharp contrast to traditional monolithic CMS platforms, where content for multiple sites is often entangled in a shared database, leading to complex permissioning schemes, high risk of human error, and difficult migrations. CrafterCMS’s Git-centric, project-based architecture gives enterprises the flexibility to scale confidently, manage content lifecycles efficiently, and support decentralized teams without sacrificing control or performance.

Decoupled Architecture

CrafterCMS is built on a truly decoupled CMS architecture, where the content authoring system (Crafter Studio) is separate from the content delivery system (Crafter Engine). This provides better security, reliability, performance, scalability, and cost-effectiveness compared to other CMSs that are only headless. For global deployments, Crafter Studio can be deployed and scaled (close to where content authors are physicall located) separately from Crafter Engine (to serve audiences most efficiently across various geographical regions).

Stateless/Serverless Content Delivery

Crafter Engine, the stateless and serverless content delivery component of CrafterCMS, offers significant advantages for scaling high-performance digital experiences. Because it requires no database at runtime, Crafter Engine eliminates the traditional bottlenecks associated with relational databases (SQL or NoSQL), simplifies deployment and operational management, and supports elastic scalability across any cloud infrastructure. 

Its stateless architecture allows multiple engine instances to run independently and horizontally scale on demand, making it ideal for high-traffic scenarios and distributed delivery. Whether serving thousands of microsites or localized experiences across regions, Crafter Engine ensures low-latency performance, high availability, and zero downtime deployment—all while dramatically reducing infrastructure complexity and operational overhead.

Easy Scaling and Sharding Support

Enterprises operating hundreds of large-scale websites, each of which could potentially contain millions of content items, often require advanced strategies to ensure performance and responsiveness. One such strategy is sharding, which involves partitioning a large content repository into smaller, self-contained segments. Each shard operates independently, managing a distinct subset of content, which significantly improves scalability, content access speed, and system resilience.

CrafterCMS fully supports this approach. Its flexible architecture enables enterprise development teams to implement custom sharding strategies based on project size, content volume, or organizational structure. Whether sharding by region, brand, or business unit, CrafterCMS ensures that each content repository remains performant and manageable at massive scale.

Scaling in CrafterCMS is designed to address both the authoring tier and the delivery tier. On the delivery side, Crafter Engine, the high-performance, stateless content delivery component, can scale horizontally without limits. Crafter Deployer, which handles artifact distribution and search indexing, and OpenSearch, the built-in enterprise search engine, also scale elastically across nodes to meet demand. Together, these components ensure that content retrieval and delivery remain fast, reliable, and globally distributed.

What enables this seamless scalability is CrafterCMS’s serverless, stateless architecture. Because there is no dependency on runtime databases or centralized state, CrafterCMS can be scaled both horizontally (across nodes or containers) and vertically (on larger instances) with minimal operational complexity. This makes it an ideal platform for high-scale, high-availability digital experience ecosystems.

Meeting Other Large Scale Enterprise or Agency Requirements

CrafterCMS also offers other features that marketers and developers need when managing an enterprise website. 

• Deployment Flexibility: CrafterCMS can be deployed using a self-hosted/self-managed enterprise version or a fully managed private SaaS in Crafter Cloud, giving enterprises the flexibility to choose the best option for them. 
  
• Powerful Content Authoring: CrafterCMS’s best-in-class content authoring includes visual content creation and preview, WYSIWYG editing, drag-and-drop experience building, and more.This gives content authors a user-friendly interface for creating, managing, and publishing large-scale digital experiences. 
  
• Developer Flexibility: CrafterCMS allows developers to use REST and/or GraphQL APIs as well as any UI framework on the front end (like React, Vue, or Freemarker) or extend the backend with Groovy or JavaScript frameworks like Node.js/Next.js.
  
• DevContentOps: CrafterCMS integrates the principles of DevOps into content-driven applications through its unique support for DevContentOps processes. This enables seamless collaboration across teams so that organizations can efficiently publish content updates, deploy new features, and deliver engaging digital experiences without the typical delays associated with traditional headless or monolithic CMS platforms. 

Learn More

Download or register for a free trial to learn more how CrafterCMS supports large-scale enterprise and agency needs.