- We offer certified developers to hire.
- We’ve performed 1500+ Web/App/eCommerce projects.
- Our clientele is 1000+.
- Free quotation on your project.
- We sign NDA for the security of your projects.
- Three months warranty on code developed by us.
Drupal multisite development is an architectural approach that allows multiple independent Drupal websites to operate from a shared Drupal codebase. Instead of maintaining a completely separate Drupal installation for every website, organizations can share the same core code, contributed modules, and common development infrastructure while keeping each website’s database, configuration, files, domain, and content separate.
Drupal’s official documentation describes multisite as a feature that can serve separate, independent websites from a single codebase. Each site can maintain its own database, configuration, files, and base domain or URL. (Drupal.org)
That distinction is important.
A Drupal multisite setup is not simply one website with multiple domains. It is also not automatically the same thing as a Drupal website using Domain Access or another domain-management solution. A properly designed Drupal multisite architecture creates a collection of Drupal sites that share an underlying application codebase while maintaining meaningful operational separation.
For organizations managing many websites, this architecture can reduce duplicated development work, simplify certain maintenance activities, and create a consistent technical foundation.
However, Drupal multisite development also introduces architectural responsibilities that do not exist to the same degree in a conventional single-site installation. A core update can affect many websites. A contributed module update can introduce compatibility problems across several properties. Shared deployment processes need stronger testing. Database isolation, file permissions, configuration management, security controls, backups, monitoring, and rollback procedures all become more important as the number of sites increases.
This is why Drupal multisite should be treated as an architectural decision rather than merely a Drupal installation technique.
A successful implementation begins by answering several questions:
These questions determine whether Drupal multisite is a practical fit.
Drupal multisite is an installation architecture in which multiple Drupal websites run from a common Drupal codebase.
The websites typically have:
The key concept is shared code with site-level separation.
Imagine an organization operates:
Instead of creating six completely unrelated Drupal installations, the organization could potentially maintain one Drupal codebase with six site configurations.
Conceptually, the architecture might look like this:
Shared Drupal Codebase
|
—————————————
| | | | |
Site A Site B Site C Site D Site E
| | | | |
DB A DB B DB C DB D DB E
Files A Files B Files C Files D Files E
Config A Config B Config C Config D Config E
The important point is that the websites remain logically distinct.
Drupal’s official installation documentation states that a single Drupal installation can host several Drupal-powered sites, each with its own individual configuration. The multisite configuration relies on site-specific directories and sites/sites.php for site selection and directory aliasing. (Drupal API)
This makes Drupal multisite particularly interesting for organizations with multiple related websites.
Understanding the architecture is more important than memorizing installation commands.
A conventional Drupal website might have a structure similar to:
drupal/
├── core/
├── modules/
├── themes/
├── sites/
│ └── default/
│ ├── files/
│ └── settings.php
├── composer.json
└── composer.lock
A multisite installation expands the sites structure.
A simplified example could look like:
drupal/
├── core/
├── modules/
│ ├── contrib/
│ └── custom/
├── themes/
│ ├── contrib/
│ └── custom/
├── sites/
│ ├── sites.php
│ ├── site-a.example.com/
│ │ ├── files/
│ │ └── settings.php
│ ├── site-b.example.com/
│ │ ├── files/
│ │ └── settings.php
│ └── site-c.example.com/
│ ├── files/
│ └── settings.php
├── composer.json
└── composer.lock
Drupal’s documented multisite folder structure can also include site-specific modules and themes directories when sites require their own code. (Drupal.org)
The architecture can therefore range from relatively simple to highly sophisticated.
The root codebase can contain:
Individual sites can have:
The precise architecture should be determined before development begins.
One of the most important decisions is determining whether multisite is actually appropriate.
There are two broad models.
Each website has its own:
For example:
Website A
├── Drupal core
├── Modules
├── Theme
└── Database
Website B
├── Drupal core
├── Modules
├── Theme
└── Database
This provides strong independence.
A change to Website A does not automatically alter Website B.
The disadvantage is duplicated maintenance.
If ten websites use the same module and a security update is required, the organization may need to update and test ten separate installations.
With multisite:
Shared Drupal Codebase
|
+— Website A
+— Website B
+— Website C
+— Website D
Core and shared dependencies can be maintained centrally.
This can significantly simplify certain operations.
However, shared code introduces shared responsibility.
A dependency update that works perfectly for one site may create a compatibility problem for another.
Therefore, multisite exchanges some duplicated maintenance for centralized dependency management.
These concepts are frequently confused.
Drupal multisite and a multidomain Drupal architecture are not necessarily the same thing.
In a traditional multisite implementation:
For example:
Codebase
|
+— Site A + Database A
|
+— Site B + Database B
|
+— Site C + Database C
A multidomain approach can instead use one Drupal site and one database while serving multiple domains.
Conceptually:
Drupal Application
|
Database
|
—————-
| | |
Domain A Domain B Domain C
The sites may share:
Depending on the implementation.
This can be useful when multiple domains are essentially variations of the same application.
The choice depends heavily on the business model.
Drupal multisite is most useful when websites share a meaningful technical foundation.
Typical scenarios include:
For example, a multinational organization may have:
Each site may need different:
But all sites may benefit from:
That is where Drupal multisite can become attractive.
Multisite should not be selected simply because there are many websites.
A shared codebase creates coupling.
If the websites have radically different:
then independent Drupal installations may provide a more manageable architecture.
For example, imagine an organization owns three websites:
Corporate website
Government-regulated portal
High-traffic media platform
If each has completely different operational requirements, forcing all three into one multisite codebase may create more complexity than it eliminates.
A good Drupal architecture considers operational independence as seriously as development efficiency.
Drupal multisite can offer substantial advantages when designed correctly.
One of the biggest benefits is the ability to share a common Drupal codebase.
Instead of maintaining:
Drupal installation A
Drupal installation B
Drupal installation C
Drupal installation D
you can maintain:
One shared Drupal codebase
with several site configurations.
This can reduce duplication.
Drupal core updates can be managed centrally.
When the organization has many websites using the same Drupal version and compatible architecture, a single codebase can simplify:
However, centralized maintenance does not mean careless maintenance.
Every affected website still needs appropriate testing.
Organizations often use the same functionality across multiple websites.
Examples include:
A shared module architecture can avoid maintaining duplicate installations of the same package.
A multisite platform can establish common engineering practices.
These might include:
This can be particularly valuable for enterprise Drupal environments.
Once a well-designed multisite platform exists, adding a new website can become more predictable.
Instead of starting from zero, developers may be able to reuse:
This does not mean every new website should be cloned blindly.
A new site should still have clearly defined requirements and a controlled configuration process.
Organizations with multiple related websites often want a consistent digital experience.
A shared Drupal platform can support reusable:
For example, an enterprise could maintain a shared design system with:
Individual websites could then use those components while maintaining their own content.
A multisite platform allows an organization to develop specialized Drupal expertise around one platform.
Teams become familiar with:
This can improve operational consistency.
Without multisite, the same custom module might be copied into multiple repositories.
That can create problems.
Suppose an organization maintains:
site-a/custom_module
site-b/custom_module
site-c/custom_module
site-d/custom_module
Over time, the versions may diverge.
With a shared platform:
shared/custom_module
can potentially serve multiple sites.
This reduces duplicate implementation.
A shared architecture can make certain improvements easier to distribute.
For example, a new:
may be implemented once and then deployed to multiple websites.
The important caveat is testing.
A shared change should never be assumed to be harmless simply because it worked on one website.
Drupal multisite environments can benefit from common DevOps tooling.
A mature platform might include:
This can transform multisite management from manual administration into a repeatable engineering process.
The benefits are significant, but multisite architecture has equally important trade-offs.
The same codebase that simplifies maintenance can increase the impact of mistakes.
If a shared module breaks:
Site A affected
Site B affected
Site C affected
Site D affected
A conventional single-site architecture might have isolated the problem.
Therefore, multisite development requires stronger:
A robust architecture should define several layers.
Drupal core is shared.
The organization should maintain a controlled version through Composer.
Drupal documentation recommends using Composer for Drupal installation and updates. Drupal 11 currently requires Composer 2.7.0 or newer according to the official system requirements documentation. (Drupal.org)
Modules used across multiple websites can live in the common codebase.
Examples may include:
modules/contrib/
redirect/
pathauto/
token/
webform/
The exact modules should depend on project requirements.
Common business logic can be placed in:
modules/custom/
Examples:
modules/custom/
corporate_common/
shared_search/
enterprise_integrations/
global_components/
These modules should be carefully designed.
A shared custom module should not assume that every website has identical content models or configuration.
Sometimes a single website needs functionality that other sites do not.
Drupal supports site-specific module and theme directories within the multisite structure. The official Drupal multisite documentation describes this option, while also warning that manually installed site-specific modules have Composer-management implications. (Drupal.org)
A site-specific structure might look like:
sites/site-a.example.com/
├── modules/
│ └── custom/
│ └── site_a_feature/
├── themes/
│ └── custom/
│ └── site_a_theme/
├── files/
└── settings.php
This provides flexibility.
However, it can also increase complexity.
If every site starts accumulating unique code, the architecture may gradually stop behaving like a coherent shared platform.
The same principle applies to themes.
An enterprise might maintain:
themes/custom/
enterprise_base/
enterprise_components/
and then create site-specific themes:
sites/site-a.example.com/themes/custom/site_a/
sites/site-b.example.com/themes/custom/site_b/
A good approach is often to establish a shared design foundation and allow controlled customization.
This can provide:
But theme inheritance and dependencies must be carefully planned.
Database separation is one of the most important considerations.
A traditional Drupal multisite architecture commonly gives each site its own database.
For example:
Drupal Codebase
|
+— Site A → database_a
|
+— Site B → database_b
|
+— Site C → database_c
This provides a strong boundary between site data.
Site A’s content does not automatically exist in Site B’s database.
This is fundamentally different from architectures where multiple domains operate from the same Drupal database.
Separate databases can provide:
For enterprise organizations, this can be extremely valuable.
Suppose Site B experiences a data corruption incident.
With independent databases, restoring Site B can potentially be performed without restoring every other site.
That operational advantage should be considered during architecture planning.
Uploaded files also need site-level separation.
A common structure is:
sites/
├── site-a.example.com/
│ └── files/
├── site-b.example.com/
│ └── files/
└── site-c.example.com/
└── files/
Drupal’s documented multisite folder structure shows separate files directories for individual sites. (Drupal.org)
This is important because uploaded files may contain:
Mixing these files can create serious operational and security problems.
Private file handling requires additional attention.
A multisite environment should clearly define:
A private file belonging to one website should never become accidentally accessible through another website.
This is one reason permissions and deployment architecture should be designed before production launch.
Each website can have its own settings.php.
For example:
sites/
├── site-a.example.com/
│ └── settings.php
├── site-b.example.com/
│ └── settings.php
└── site-c.example.com/
└── settings.php
The settings file can contain site-specific information such as:
Drupal’s API documentation specifically identifies settings.php as the site-specific configuration file and explains how Drupal discovers site configuration directories. (Drupal API)
The sites/sites.php file is central to Drupal multisite configuration.
Drupal provides an example.sites.php file that can be copied to sites/sites.php.
The file allows hostname, port, and path mappings to be associated with specific site directories. (Drupal API)
A simplified example is:
$sites[‘site-a.example.com’] = ‘site-a.example.com’;
$sites[‘site-b.example.com’] = ‘site-b.example.com’;
$sites[‘site-c.example.com’] = ‘site-c.example.com’;
The exact implementation depends on the deployment architecture.
The important concept is that Drupal uses these mappings to determine which site’s configuration should handle an incoming request.
When a request reaches a multisite Drupal installation, Drupal needs to determine which site configuration applies.
Conceptually:
Incoming Request
|
v
Domain / Hostname
|
v
Drupal Site Resolution
|
v
Site Directory
|
v
settings.php
|
v
Database
|
v
Requested Page
A mistake at the site-resolution layer can produce confusing behavior.
For example, the wrong website might appear when:
This is why domain configuration must be tested independently for every site.
DNS is not technically part of Drupal itself, but it is essential to the architecture.
Suppose the organization has:
www.example.com
www.example.co.uk
www.example.de
Each domain needs to resolve to the correct infrastructure.
Depending on the infrastructure, DNS records may include:
A typical request flow could be:
Visitor
|
v
DNS
|
v
CDN / Load Balancer
|
v
Web Server
|
v
Drupal Multisite
|
v
Correct Site Configuration
This should be documented as part of the platform architecture.
Drupal multisite commonly requires the web server to route multiple domains to the same Drupal document root.
For example:
site-a.example.com ─┐
site-b.example.com ─┼──> Drupal document root
site-c.example.com ─┘
The web server does not necessarily point each domain to a different physical Drupal installation.
Instead, several domains can reach the shared Drupal codebase, while Drupal determines which site configuration should handle the request.
Drupal’s official multisite setup documentation provides an example where the virtual host for a site points to the root Drupal installation rather than directly to that site’s subdirectory. (Drupal.org)
Every production domain should be configured for HTTPS.
For example:
https://site-a.example.com
https://site-b.example.com
https://site-c.example.com
Depending on the infrastructure, certificates can be managed through:
The architecture should account for:
A certificate configuration that works for one domain does not automatically mean every domain is correctly secured.
Composer should be central to modern Drupal multisite development.
Drupal’s official documentation recommends Composer for installation and updates. (Drupal.org)
A typical project may contain:
composer.json
composer.lock
These files define the project’s dependencies.
For example:
Drupal core
|
+— Contributed module A
+— Contributed module B
+— Custom package
+— Third-party library
In a multisite environment, dependency management becomes particularly important because the same dependency can affect multiple websites.
The lock file provides reproducibility.
Instead of saying:
Install whatever version currently satisfies these constraints.
the project can use the locked dependency versions.
This helps ensure that:
Development
|
v
Staging
|
v
Production
uses consistent dependencies.
For multisite environments, reproducibility becomes even more valuable because several websites may rely on the same dependency graph.
Configuration management is one of the most challenging parts of multisite development.
Drupal configuration can include:
A multisite environment needs to determine:
These questions should be answered before the project becomes large.
Imagine five websites share the same content architecture.
You might have common configuration for:
But individual sites may need:
Trying to force all configuration into one identical package can become restrictive.
Conversely, allowing every site to modify everything independently can eliminate the benefits of standardization.
The goal is controlled variation.
Configuration Split is often considered when different environments or sites need different configuration sets.
A common conceptual model is:
Base Configuration
|
————-
| | |
Site A Site B Site C
Overrides
This can allow a platform team to establish a common foundation while maintaining controlled differences.
However, Configuration Split should not be treated as a magic solution.
Poorly structured configuration dependencies can still create deployment problems.
Teams should define:
Deployment is one of the most important parts of multisite architecture.
A basic deployment pipeline might look like:
Developer
|
v
Git Commit
|
v
CI Pipeline
|
+— Code Tests
+— Drupal Tests
+— Security Checks
+— Composer Validation
+— Configuration Validation
|
v
Staging
|
v
Multisite Testing
|
v
Production
A mature pipeline should test more than whether the Drupal application starts.
It should verify that affected websites continue to function.
Consider a shared module update.
The change may pass testing on:
Site A
but fail on:
Site C
because Site C uses:
Therefore, multisite deployment testing should cover representative site types.
For a platform with 20 sites, it may not be practical to perform every possible manual test on every deployment.
Instead, organizations can establish:
A strong CI/CD system can automate many checks.
Possible pipeline stages include:
Check:
Check:
Check:
Check:
Check:
Automation reduces the chance of human error.
Security deserves special attention because shared infrastructure can increase the blast radius of vulnerabilities.
A multisite security strategy should consider:
Drupal’s own configuration files include warnings about protecting sensitive settings files from inappropriate write permissions. (Drupal API)
Suppose a vulnerable shared module exists in the codebase.
If that module is enabled across:
Site A
Site B
Site C
Site D
Site E
the vulnerability may affect multiple websites.
This is why security updates should follow a controlled emergency process.
A mature organization should be able to:
The shared architecture makes centralized patching easier, but it also makes timely action more important.
Trusted host configuration should be carefully designed when several domains point to one Drupal installation.
The platform should explicitly define which hostnames are legitimate.
For example, the architecture might recognize:
site-a.example.com
site-b.example.com
site-c.example.com
rather than accepting arbitrary host headers.
This helps reduce host-header-related risks and prevents unexpected domain handling.
User architecture requires an important decision.
Should users be:
Traditional Drupal multisite sites with separate databases naturally provide separate user stores.
This may be desirable when:
Site A users ≠ Site B users
But multinational organizations sometimes want:
One corporate identity
|
—————–
| | |
Site A Site B Site C
In such cases, external identity systems and authentication integrations may be more appropriate.
Enterprise organizations may integrate Drupal websites with:
This can provide centralized authentication while preserving site-level Drupal architecture.
However, SSO does not necessarily mean that all sites should share the same Drupal user database.
Authentication and application authorization are separate architectural concerns.
Each website may have different editorial teams.
For example:
Site A
Editors
Publishers
Administrators
Site B
Editors
Publishers
Administrators
Site C
Editors
Translators
Publishers
Administrators
Permissions should be designed around least privilege.
Do not assume that because users belong to the same organization they should automatically receive administrative access across every site.
Multisite architecture makes access boundaries especially important.
Performance planning should begin before production.
A multisite installation can serve many websites from the same infrastructure.
That creates shared resource consumption.
Potential shared resources include:
A traffic spike on one website may therefore influence other websites if the infrastructure is not designed appropriately.
Imagine:
Site A: 5,000 visits/day
Site B: 8,000 visits/day
Site C: 2,000 visits/day
Site D: 1,500,000 visits/day
If all four sites share the same PHP worker pool and database resources, Site D’s traffic could consume a disproportionate amount of capacity.
This is a classic noisy-neighbor problem.
Solutions can include:
Multisite does not automatically mean all infrastructure must be shared.
The codebase can be shared while infrastructure is selectively separated.
Caching is particularly important for multisite.
Potential caching layers include:
Browser Cache
|
v
CDN
|
v
Reverse Proxy
|
v
Drupal Cache
|
v
Redis / Cache Backend
|
v
Database
Each layer should understand site boundaries.
Cache keys should not accidentally allow one site’s content to be served for another site’s request.
This is particularly important when domains share:
Redis can be used for caching and other high-performance application infrastructure.
In multisite environments, teams should ensure that cache namespaces or prefixes prevent collisions between websites where required.
Conceptually:
site_a:cache
site_b:cache
site_c:cache
instead of treating the entire multisite platform as one undifferentiated cache namespace.
The exact implementation depends on the Drupal and infrastructure architecture.
Large multisite platforms often need search infrastructure.
Possible architecture:
Site A ─┐
Site B ─┼──> Search Platform
Site C ─┘
The search platform could support:
For example:
index_site_a
index_site_b
index_site_c
This provides stronger isolation.
Alternatively:
global_index
|
+— site_id=A
+— site_id=B
+— site_id=C
may be appropriate where cross-site search is required.
Search architecture should therefore be decided according to business requirements rather than convenience.
Content governance is often overlooked.
Technical separation is only one side of multisite.
Organizations should also define:
A technically elegant multisite platform can still become difficult to manage if governance is unclear.
Multilingual organizations are a common use case.
There are several possible models.
example.com
|
+— English
+— French
+— German
example.com
example.fr
example.de
example.jp
Some regions use multilingual single sites while others have independent sites.
Drupal multisite can support the third model, but governance becomes more important.
The organization should decide whether language variation represents:
International SEO introduces additional requirements.
A multisite network may need:
For example:
example.com/en/
example.com/fr/
example.de/
example.fr/
should not be treated as interchangeable.
Search engines need clear signals about relationships between regional and language variants.
Organizations sometimes want content created once and distributed across multiple sites.
For example:
Global newsroom
|
+— US site
+— UK site
+— Canada site
+— Australia site
This can be implemented through various Drupal integration patterns.
However, content syndication is different from multisite itself.
Multisite provides an architectural foundation.
It does not automatically provide centralized content distribution.
A content syndication strategy must define:
Modern Drupal websites frequently integrate with external systems.
Examples include:
In a multisite architecture, teams should decide whether integrations are:
For example:
Shared CRM Integration
|
——————
| | |
Site A Site B Site C
may be appropriate if every website uses the same CRM.
But if every website connects to a different CRM account, site-specific configuration becomes necessary.
A common pattern is:
Drupal Multisite
|
+— REST API
+— JSON:API
+— Custom API
+— External Services
Each site may expose different data.
Security controls should ensure that:
A multisite platform can also support headless Drupal.
For example:
Drupal Multisite
|
——————————-
| | |
Site A Site B Site C
| | |
Next.js Next.js React
The Drupal backend manages content while separate frontend applications consume APIs.
This can be powerful but increases architectural complexity.
Teams must coordinate:
Hosting requirements depend on scale.
A small multisite environment might use:
Web Server
|
PHP
|
Drupal
|
Database Server
A larger enterprise platform may use:
CDN
|
Load Balancer
|
———————–
| | |
Web/PHP Web/PHP Web/PHP
| | |
———–|———-
|
Shared Services
/ | \
Redis Search Queue
|
Databases
The correct architecture depends on:
Drupal multisite can be hosted on major cloud platforms.
Potential infrastructure components include:
The cloud provider itself is less important than the architecture.
A poorly designed cloud architecture can still produce:
Cloud hosting does not automatically solve multisite complexity.
Docker-based development can make multisite environments easier to reproduce.
A development environment might contain:
Docker
├── PHP
├── Nginx
├── MySQL/PostgreSQL
├── Redis
└── Solr
The multisite codebase can then be used consistently across developers.
Drupal’s system requirements documentation also identifies DDEV as a recommended Drupal development tool and notes that it provides current PHP versions. (Drupal.org)
Containerization can help reduce:
But the production architecture should still be designed independently of local development convenience.
A good development environment should make it easy to switch between sites.
For example:
site-a.local
site-b.local
site-c.local
Developers should be able to:
The development process should closely resemble staging and production.
Drush can be particularly useful in multisite environments.
Common administrative tasks may include:
drush status
drush cr
drush updb
drush cim
drush cex
drush config:export
drush config:import
The exact commands and workflow depend on Drupal version and project standards.
The critical issue is ensuring that commands execute against the intended site.
Running a database update against the wrong site can have serious consequences.
Multisite environments should establish clear conventions for selecting the correct site.
For example:
drush –uri=https://site-a.example.com status
can explicitly target a site.
The principle is more important than the exact command:
Make the target site explicit whenever an administrative operation could affect production data.
This is particularly important for:
Backups must operate at multiple levels.
A robust strategy may include:
Each site’s database should be backed up independently.
Each site’s uploaded files should be backed up separately.
The Git repository and deployment artifacts should be preserved.
Configuration should be version-controlled where appropriate.
Infrastructure-as-code definitions should also be preserved.
The goal is not merely to have “a backup.”
The goal is to be able to restore a specific website reliably.
Disaster recovery planning should define:
For example:
Site A Failure
|
v
Restore Database A
|
v
Restore Files A
|
v
Deploy Shared Code
|
v
Restore Configuration
|
v
Validate Site A
|
v
DNS / Traffic Recovery
A multisite platform should ideally allow one site to be recovered without unnecessarily restoring every other website.
Monitoring should happen at both platform and site levels.
Track:
Track:
A platform can be healthy overall while one website is broken.
Monitoring therefore needs site awareness.
Centralized logging can help identify platform-wide issues.
Logs may include:
Logs should identify the relevant website.
For example:
timestamp
site_id
request
status
response_time
user
error
Without site context, troubleshooting a large multisite platform can become unnecessarily difficult.
Performance testing should simulate realistic workloads.
Instead of testing only:
Site A
a large platform should consider scenarios such as:
Site A normal traffic
Site B normal traffic
Site C high traffic
Site D background jobs
Site E content publishing
The purpose is to understand whether activity on one website affects another.
Even with separate databases, infrastructure can be shared.
Potential bottlenecks include:
A site with heavy traffic can still influence other websites if all databases reside on the same database server.
This is another example of why code isolation and infrastructure isolation are separate decisions.
Scaling strategies can include:
A useful strategy is to allow the architecture to evolve.
For example:
Shared codebase
|
+— Site A → shared infrastructure
+— Site B → shared infrastructure
+— Site C → dedicated infrastructure
The codebase can remain shared even if one website eventually requires dedicated resources.
High-traffic websites require special consideration.
If one website receives a major campaign surge, the organization should determine:
A flexible architecture prevents the entire multisite platform from becoming constrained by its busiest website.
A mature platform may evolve through several stages.
One server
One database server
Several sites
Load balancer
Multiple application servers
Separate databases
CDN
Load balancing
Autoscaling
Managed databases
Redis
Search cluster
Object storage
Shared Drupal code
Site-specific infrastructure
Global CDN
Regional deployment
Dedicated resources for critical sites
The right stage depends on actual requirements rather than theoretical scale.
Technology alone does not solve governance.
A large Drupal multisite platform should establish ownership.
A possible model is:
Responsible for:
Responsible for:
Responsible for:
Responsible for:
This creates clearer accountability.
Before development begins, document answers to:
These questions become increasingly important as the number of websites grows.
Naming conventions might appear minor, but they become important in large installations.
A project should define naming rules for:
For example:
site-us
site-uk
site-de
site-fr
site-in
or:
corporate-us
corporate-uk
corporate-de
corporate-fr
corporate-in
The exact convention matters less than consistency.
Every production multisite should have architecture documentation.
At minimum, document:
A diagram can be particularly useful.
CDN
|
Load Balancer
|
Drupal Codebase
|
——————————–
| | |
Site A Site B Site C
| | |
DB-A DB-B DB-C
| | |
Files-A Files-B Files-C
Documentation should be updated whenever the architecture changes.
Upgrading Drupal core is one of the most important multisite maintenance activities.
A disciplined process might be:
The precise process will vary by project.
Current Drupal system requirements matter when designing or upgrading a multisite platform.
Drupal’s official documentation currently lists PHP 8.3 and newer requirements for Drupal 11, with database requirements including MySQL 8.0+, MariaDB 10.6+, PostgreSQL 16+, and SQLite 3.45+. (Drupal.org)
This matters because all websites sharing a Drupal codebase must be compatible with the platform’s supported runtime.
If one website requires an older PHP version that another site’s Drupal version does not support, a shared multisite architecture may become impractical.
This is one of the most important compatibility questions to answer before migration.
Suppose:
Site A requires Drupal 11
Site B requires Drupal 11
Site C remains on Drupal 10
A shared codebase cannot simply satisfy both requirements indefinitely.
This illustrates a key multisite principle:
Shared code creates shared upgrade boundaries.
Before combining sites into one multisite installation, verify:
Module management requires governance.
A useful classification is:
Used by most or all sites.
Available to sites but not necessarily enabled everywhere.
Required by one or a small subset of websites.
Modules scheduled for replacement or removal.
This classification makes the codebase easier to understand.
A common multisite problem is uncontrolled growth.
Imagine:
Site A adds 5 modules
Site B adds 8 modules
Site C adds 12 modules
Site D adds 7 modules
Eventually the shared platform contains dozens of dependencies that only a few websites need.
This can make:
A module governance process can help prevent this.
The same principle applies to themes.
A platform should define:
A site should not independently introduce an entirely different frontend architecture without considering platform consequences.
Accessibility should be part of the shared platform.
Reusable components should be designed with accessibility in mind.
Important areas include:
A shared component library can help distribute accessibility improvements across sites.
But site-specific content and custom components still require testing.
SEO should be treated as both a platform and site responsibility.
Platform-level SEO can standardize:
Individual websites may still need:
A shared technical foundation should not force identical SEO strategies onto unrelated websites.
Each website may have separate analytics requirements.
For example:
Site A → Analytics Property A
Site B → Analytics Property B
Site C → Analytics Property C
The implementation can be shared while identifiers remain site-specific.
Configuration should therefore distinguish:
Shared analytics module
+
Site-specific measurement ID
This pattern applies to many external integrations.
Common integrations include:
Every integration should be classified as:
Secrets should not be committed to source code.
Instead, use appropriate environment-level secret management.
A professional setup should distinguish:
Development
Staging
Production
For multisite, staging should represent the actual production architecture closely enough to reveal cross-site problems.
A staging environment might include:
site-a.stage.example.com
site-b.stage.example.com
site-c.stage.example.com
This allows the platform team to validate domain routing and site resolution before production.
Local development may use:
site-a.local
site-b.local
site-c.local
Developers should be able to reproduce site-specific behavior.
A new developer joining the project should not need to manually construct every environment component.
Good local onboarding documentation can specify:
Testing should occur at several levels.
Tests individual classes and components.
Tests Drupal functionality with the framework.
Tests application behavior.
Tests real user interactions.
Tests external systems.
Tests site routing and isolation.
This last category is particularly important.
Testing should verify that:
These tests protect the architecture itself.
Security isolation should exist at multiple levels.
Separate database credentials.
Separate file directories and permissions.
Separate settings.
Appropriate site-level authorization.
Appropriate resource boundaries.
Site-aware logging and alerting.
Controlled site-specific operations.
Isolation reduces the potential impact of accidental changes.
Do not assume one database user should have unrestricted access to every database.
Where practical, database access should follow least privilege.
For example:
Site A → DB A → User A
Site B → DB B → User B
Site C → DB C → User C
This improves isolation.
The exact model depends on the hosting architecture, but database permissions should be deliberately designed.
File permissions should prevent one site from modifying another site’s files unnecessarily.
A poor permission model can undermine database isolation.
For example:
site-a/files
site-b/files
site-c/files
should have carefully controlled ownership and permissions.
Writable directories should be limited to those that genuinely need write access.
Cron becomes another operational consideration.
Should cron run:
for every site
or should jobs be scheduled individually?
A large multisite platform may have:
The architecture should prevent one site’s long-running job from starving other sites.
Drupal queues can be useful for:
Multisite platforms should determine whether queues are:
For example:
queue:site_a
queue:site_b
queue:site_c
can provide better operational visibility than an opaque shared queue.
Search indexing can become resource-intensive.
If one site contains millions of records while another contains a few thousand, the indexing strategy should account for the difference.
Potential approaches include:
Search should not become an unmonitored shared bottleneck.
Media is another major consideration.
Each site may have:
The organization must decide whether media is:
A shared media library can provide efficiency but increases permission and governance complexity.
Large organizations may store files in cloud object storage rather than relying exclusively on local disk.
Potential benefits include:
However, object storage should still preserve site boundaries.
A conceptual structure might be:
bucket/
site-a/
site-b/
site-c/
The exact implementation depends on the storage platform.
Migrating existing websites into a multisite architecture requires careful planning.
Suppose an organization currently has:
Site A → Drupal installation A
Site B → Drupal installation B
Site C → Drupal installation C
The target becomes:
Shared Drupal codebase
|
+— Site A
+— Site B
+— Site C
The migration should begin with compatibility analysis.
Before migration, inventory:
This inventory identifies incompatibilities early.
A practical migration can follow:
Document existing systems.
Identify conflicting dependencies.
Design the target multisite structure.
Create the shared codebase.
Move individual sites.
Validate functionality and isolation.
Measure shared infrastructure behavior.
Move traffic carefully.
Watch for issues after launch.
Common migration risks include:
A detailed migration plan reduces these risks.
SEO migration deserves special attention.
If a website moves into a multisite architecture but its URLs remain unchanged, the SEO risk can be lower than a migration that changes the URL structure.
However, architecture changes can still affect:
Every production domain should be crawled and validated after migration.
Content migration should preserve:
The migration method should be automated whenever practical.
Manual copying of large websites creates unnecessary risk.
Configuration is different from content.
A site migration may involve:
Content
+
Files
+
Database
+
Configuration
+
Code
These should be handled separately.
Configuration should be version-controlled where appropriate and imported through a controlled process.
The cost of Drupal multisite development depends on architecture rather than simply the number of websites.
Major cost drivers include:
A five-site multisite platform can be more complicated than a ten-site platform if the five websites have highly divergent requirements.
The largest cost categories are often:
Determines how the platform will operate.
Combines reusable functionality.
Moves existing websites into the new structure.
Creates a sustainable deployment model.
Provides reliable hosting.
Automates deployment and testing.
Protects the shared platform.
Ensures that changes do not break individual websites.
Keeps the platform healthy.
A multisite architecture may appear inexpensive if the project is evaluated only by initial development hours.
But inadequate architecture can create long-term costs.
For example:
Poor dependency management
↓
Frequent deployment problems
↓
Manual fixes
↓
Production downtime
↓
Higher maintenance costs
Similarly:
Poor configuration management
↓
Site-specific drift
↓
Deployment conflicts
↓
Slower releases
The objective should therefore be sustainable platform engineering rather than minimum initial cost.
Ongoing maintenance should include:
The platform should have a defined maintenance calendar.
Security updates should have an accelerated path.
A normal feature update might follow:
Development
→ QA
→ Staging
→ Production
A critical security issue may require:
Security Advisory
→ Impact Assessment
→ Emergency Patch
→ Focused Testing
→ Production
→ Monitoring
The exact process depends on severity.
The important point is that security response should not depend on ad hoc decision-making.
Technical debt can accumulate rapidly when individual sites are allowed to diverge without governance.
Warning signs include:
A platform governance process can reduce these problems.
Configuration drift occurs when production configuration differs from the intended version-controlled configuration.
For example:
Git configuration
≠
Production configuration
Over time, developers may no longer know which state is authoritative.
A mature platform establishes:
Version-controlled configuration
↓
Controlled deployment
↓
Production
and minimizes manual configuration changes.
A release process should distinguish between:
For example:
Platform Release 2026.09
|
+— Site A
+— Site B
+— Site C
while a site-specific feature might follow:
Site B Feature
|
+— Site B only
The deployment system should make this distinction clear.
Every production deployment should have a rollback plan.
Rollback may involve:
Database rollback is particularly complicated.
A code rollback does not necessarily reverse database schema changes.
Therefore, deployment procedures should explicitly document which changes are reversible and which require forward fixes.
Consider several scenarios.
The architecture should allow restoration of that site’s:
without unnecessarily restoring all sites.
The platform should support:
Backups and recovery infrastructure become essential.
CDN and scaling strategies should protect the platform.
The shared dependency should be patched quickly.
These scenarios should be included in disaster recovery exercises.
The following practices can significantly improve long-term maintainability.
Do not build multiple websites independently and attempt to combine them later without a detailed architecture review.
Explicitly document:
Document:
Manage dependencies consistently through Composer.
Track application code and relevant configuration.
Reduce manual production operations.
Do not validate only one website.
Ensure individual sites can be restored.
Platform-level monitoring alone is insufficient.
Define ownership and change control.
Too much divergence defeats the purpose of multisite.
Several mistakes repeatedly create problems.
It does not.
A good multisite architecture intentionally separates:
while sharing selected technical resources.
This gradually creates a collection of unrelated applications inside one codebase.
The shared platform becomes difficult to maintain.
A shared dependency can behave differently depending on:
Representative testing is essential.
If databases are not properly separated or credentials are misconfigured, the consequences can be severe.
Each site’s uploaded assets should have a clear storage boundary.
Configuration management should be part of architecture from the beginning.
Manual changes create configuration drift and make deployments difficult to reproduce.
A high-traffic website can consume shared resources.
Resource planning should account for traffic differences.
DNS, web server configuration, and Drupal site mapping must work together.
It can reduce duplication, but it also introduces shared-platform engineering requirements.
Before adopting multisite, ask:
If these questions cannot be answered clearly, the architecture needs further discovery before development begins.
A simplified comparison can help.
| Requirement | Drupal Multisite | Multidomain |
| Separate databases | Strong fit | Usually not the primary model |
| Separate site configuration | Strong fit | More shared |
| Separate content | Strong fit | Requires application design |
| Shared code | Yes | Yes |
| Shared users | Possible through integration | More natural depending on architecture |
| Independent site administration | Strong fit | More centralized |
| Independent restoration | Strong fit | More complicated if one database |
| Shared content | Requires integration | Often easier |
| Completely independent sites | Strong fit | Less suitable |
| Single application experience | Less centralized | Stronger fit |
Neither architecture is universally correct.
The correct choice depends on the required degree of separation.
Enterprise organizations often have the strongest use case for multisite because they may operate dozens or hundreds of digital properties.
Potential enterprise examples include:
However, enterprise scale also increases governance requirements.
At larger scale, the platform should behave like an internal product.
That means having:
Universities often operate numerous web properties.
For example:
University
|
+— Main website
+— Business school
+— Engineering school
+— Medical school
+— Research center
+— Alumni
+— Admissions
A multisite architecture can provide shared infrastructure while allowing departments to maintain their own content.
But governance is particularly important because departments may have different levels of technical expertise.
Central platform teams should establish clear rules around:
Government organizations may manage many public-facing properties.
Potential benefits include:
But government environments can also have strict requirements around:
Those requirements must be evaluated individually before sites are combined.
Global brands are another common scenario.
A central organization may want:
Global Design System
Global Drupal Platform
Global Security Standards
Global SEO Framework
while allowing countries to control:
Local Content
Local Promotions
Local Legal Requirements
Local Contact Information
Local Languages
This is a strong example of where controlled standardization can create value.
Media organizations may operate:
Performance becomes particularly important here.
High-traffic publishing environments can generate:
A scalable caching and CDN strategy should therefore be designed from the beginning.
Franchise organizations may operate hundreds of location websites.
A potential architecture is:
Shared Drupal Platform
|
——————–
| | | | |
Store Store Store Store …
Common functionality may include:
But each location may have independent content.
The architecture should prevent one location from accidentally editing another location’s data.
If hundreds of sites are involved, manual provisioning becomes impractical.
Automation can help create:
A provisioning pipeline might look like:
New Site Request
|
v
Approval
|
v
Automated Provisioning
|
+— Database
+— Files
+— Configuration
+— Domain
+— Monitoring
|
v
Ready for Editors
This turns multisite into a repeatable platform capability.
Automation becomes increasingly valuable as site count increases.
Potential automation targets include:
The goal is to eliminate repetitive manual work.
For organizations that want higher levels of Drupal hosting automation, Aegir is another technology worth evaluating.
Drupal’s official multisite setup documentation references Aegir as a hosting system that can automate significant portions of multisite management, including virtual hosts, HTTPS configuration, Composer operations, and platform management. (Drupal.org)
Aegir is not mandatory for Drupal multisite.
Organizations can build their own automation using:
The appropriate choice depends on the team’s skills and infrastructure.
Infrastructure as code can help make environments reproducible.
Instead of manually configuring:
Server
Database
Load Balancer
CDN
Storage
Monitoring
the organization can define infrastructure declaratively.
This helps with:
Multisite environments benefit significantly from this approach because infrastructure complexity increases with site count.
At larger scale, Drupal multisite becomes a platform engineering problem.
The organization is no longer simply building websites.
It is building:
A reusable digital platform capable of hosting multiple Drupal applications.
That platform needs:
Thinking this way helps teams avoid treating multisite as merely a directory configuration.
A professional workflow can follow this lifecycle:
Requirements
↓
Architecture
↓
Shared Platform Design
↓
Site-Specific Design
↓
Development
↓
Automated Testing
↓
Staging
↓
Multisite Validation
↓
Production
↓
Monitoring
↓
Continuous Improvement
Each stage should have clear ownership.
Start with an inventory.
Create a spreadsheet containing:
| Site | Drupal Version | PHP | Modules | Database | Traffic | Custom Code | Owner |
| Site A | Current | Supported | Medium | Separate | Medium | High | Team A |
| Site B | Current | Supported | High | Separate | High | Medium | Team B |
| Site C | Current | Supported | Low | Separate | Low | Low | Team C |
The exact information should be adapted to the organization.
This inventory quickly exposes incompatible sites.
A useful architecture exercise is to compare websites.
Evaluate:
Then classify sites into groups.
For example:
Group A
Highly similar sites
Group B
Mostly similar sites
Group C
Highly customized sites
Sites in Group A may be strong multisite candidates.
Group C may require independent architecture.
Before migrating dozens of sites, build a proof of concept.
A good POC might include:
The POC should intentionally include one complicated site.
Testing only easy sites can create false confidence.
A pilot should answer practical questions:
These findings should inform the final architecture.
Before production, establish measurable criteria.
Examples include:
Clear acceptance criteria prevent subjective launch decisions.
Before launch:
A large multisite platform should rarely be launched blindly.
A staged launch may be safer:
Pilot Site
↓
Small Group
↓
Medium Group
↓
Remaining Sites
This provides opportunities to identify problems before the entire platform is migrated.
The rollout can also reveal infrastructure bottlenecks.
The first days after migration deserve increased monitoring.
Watch:
Compare metrics with pre-migration baselines where available.
A multisite platform should have a roadmap.
Potential roadmap items include:
A roadmap prevents the platform from becoming stagnant.
The most important principle is simple:
Do not choose Drupal multisite merely because multiple websites exist. Choose it when the websites have enough common technical and operational characteristics to benefit from a shared platform.
A successful Drupal multisite architecture usually has:
Drupal’s native multisite architecture is flexible enough to support separate websites from one codebase, but that flexibility needs disciplined engineering. The official Drupal documentation confirms that individual sites can maintain their own databases, configuration, files, and URLs while using the same underlying codebase. (Drupal.org)
The technical challenge is therefore not simply creating another directory under sites.
The real challenge is creating a platform in which shared resources provide efficiency without destroying the independence that individual websites need.
When that balance is achieved, Drupal multisite can become a powerful foundation for enterprise website portfolios, international digital ecosystems, educational networks, government properties, franchises, publishers, and organizations managing many related Drupal websites.