ChatGPT answers, unedited

If you mean multiple independent WordPress Multisite networks, each hosting a set of client microsites, I’d structure it like this:

Recommended stack

• Ubuntu/Debian + Nginx — web server and TLS termination.
• PHP-FPM — ideally a separate PHP-FPM pool per network/client group when isolation matters.
• MariaDB/MySQL — separate database (or at least separate DB users) per Multisite network.
• Redis — object caching; separate logical databases/prefixes as appropriate.
• WP-CLI — provisioning, updates, backups, and automation.
• Let's Encrypt — automated HTTPS.
• Cloudflare — DNS, CDN, basic WAF/rate limiting, and wildcard DNS where useful.
• A deployment/provisioning layer — Ansible, Terraform, or your own scripts.

The important architectural point is that WordPress Multisite is a network boundary, not a strong isolation boundary. If Client A and Client B are in the same Multisite network, they share WordPress core, plugins, themes, database infrastructure, and much of the operational surface.

For client microsites, I'd generally use:

                    Host
                     │
          ┌──────────┴──────────┐
          │       Nginx         │
          └──────────┬──────────┘
                     │
       ┌─────────────┼─────────────┐
       │             │             │
   Network A      Network B      Network C
   Multisite      Multisite      Multisite
       │             │             │
    PHP-FPM        PHP-FPM        PHP-FPM
       │             │             │
    DB A           DB B           DB C
       └─────────────┼─────────────┘
                     │
                   Redis

But there's another option

If you're expecting dozens/hundreds of unrelated client sites, I'd seriously consider one WordPress installation per client rather than putting all clients into a handful of Multisite networks.

Use Multisite when the sites genuinely benefit from shared administration—for example:

clientbrand.com
location1.clientbrand.com
location2.clientbrand.com
location3.clientbrand.com

Use independent WordPress installations when clients need different plugins, versions, administrators, staging environments, or stronger failure isolation.

For a hosting operation, I'd optimize around automation and isolation, rather than simply trying to cram the maximum number of sites onto one VPS.

If you tell me roughly how many microsites (10 / 50 / 500+), whether they're subdomains or custom domains, and your VPS specs, I can lay out a concrete architecture—including Nginx, PHP-FPM pools, MariaDB, Redis, backups, and automated site provisioning.

If you mean multiple independent WordPress Multisite networks, each hosting several client microsites, on a single server, I’d structure it like this:

Recommended stack

• Ubuntu/Debian
• Nginx or Caddy as the reverse proxy/web server
• PHP-FPM with separate pools where useful
• MariaDB/MySQL
• Redis for object caching
• Docker Compose if you want clean isolation and reproducible deployments
• WP-CLI for provisioning/maintenance
• Cloudflare in front for DNS, TLS, caching, and basic protection

The important distinction is that one WordPress Multisite network is not the same thing as multiple networks. If clients need meaningful isolation—separate plugins/themes, administrators, upgrades, databases, or security boundaries—I would generally run one WordPress installation/container + database per client/network, rather than trying to put all clients into one enormous Multisite installation.

A practical layout could be:

                    Cloudflare
                        │
                   Nginx/Caddy
                        │
        ┌───────────────┼────────────────┐
        │               │                │
   Client A         Client B          Client C
   Multisite        Multisite         Multisite
        │               │                │
   PHP-FPM A        PHP-FPM B         PHP-FPM C
   DB A             DB B              DB C
   Redis            Redis             Redis

For dozens to hundreds of microsites, I’d favor containerized per-network deployments plus automation rather than manually maintaining each installation.

If you tell me roughly how many client networks/microsites you expect (e.g. 10, 50, 500) and whether they need custom domains, I can recommend a concrete architecture and sizing.

If you mean multiple independent WordPress Multisite networks, each hosting a set of client microsites, I’d generally use:

Best setup

One VPS + Docker + Nginx/Traefik + separate WordPress stacks per network

For example:

Host
├── Network A
│   ├── client1.com
│   ├── client2.com
│   └── client3.com
├── Network B
│   ├── client4.com
│   ├── client5.com
│   └── client6.com
└── Network C
    ├── client7.com
    └── client8.com

Each network gets its own WordPress installation/database, while the host shares infrastructure such as:

• Nginx/Traefik for reverse proxy + SSL
• PHP-FPM containers
• Redis object cache
• MariaDB/MySQL
• automated backups
• monitoring/logging

Why I wouldn't put everything into one giant Multisite

If these are different clients, separate networks give you much better isolation. A plugin failure, bad configuration, compromised administrator account, or resource-heavy client is less likely to affect everyone else.

I'd use a single Multisite network only when the sites are essentially part of the same organization/product and you want centralized administration, themes, plugins, and users.

If you want something more turnkey

If your goal is specifically "I want to sell/manage dozens of WordPress microsites from one server", I'd also look at a WordPress management/provisioning layer rather than building all the infrastructure yourself. wordpress.org is the underlying CMS, but the right hosting architecture depends heavily on whether you're talking about 5, 50, or 500 sites.

If you tell me roughly how many networks/sites, expected traffic, and whether each client needs their own WP admin, I can recommend a concrete stack (e.g. Docker vs. Plesk vs. RunCloud vs. bare Nginx, database layout, backups, SSL, and resource limits).

If these are different clients, separate networks give you much better isolation. A plugin failure, bad configuration, compromised administrator account, or resource-heavy client is less likely to affect everyone else.

I'd use a single Multisite network only when the sites are essentially part of the same organization/product and you want centralized administration, themes, plugins, and users.

If you want something more turnkey

For multiple WordPress Multisite networks hosting client microsites on one server, I’d use:

• Nginx + PHP-FPM — efficient, isolated pools per network if needed.
• MariaDB/MySQL — separate database per network for cleaner client boundaries.
• Docker Compose — package each network’s web/PHP stack while sharing infrastructure.
• Redis Object Cache — especially useful with many sites.
• Cloudflare — DNS, TLS, caching, and basic protection.
• WP-CLI + Git/Composer — deployment and maintenance automation.

If you expect dozens/hundreds of client sites, I’d strongly consider one containerized WordPress Multisite network per client/project, rather than putting every client into one giant network.

If you want to run multiple WordPress Multisite networks for client microsites on a single host, the best setup depends on how many clients you have, how much isolation you need, and whether you’re managing this as an agency/platform.

A few common architectures:

Option 1: Multiple WordPress Multisite installs (usually the best choice)

Run one WordPress Multisite network per client group rather than trying to put everything into one giant network.

Example:

• client-a.com → WordPress Multisite install A - site1.client-a.com
• site2.client-a.com
• client-b.com → WordPress Multisite install B - site1.client-b.com
• site2.client-b.com

Advantages:

• Better client isolation
• Separate plugin/theme stacks
• Easier backups and migrations
• A broken update in one network does not affect everyone
• Easier to hand off a client later

This is the approach I’d generally use for an agency hosting client microsites.

Option 2: WordPress Multisite Networks using a management layer

If you have dozens or hundreds of microsites, consider a platform designed around this.

Good options:

• MainWP — good for managing many separate WordPress installs
• InfiniteWP — another WordPress management platform
• WP Engine — managed WordPress hosting with strong multisite support
• Pantheon Systems — enterprise WordPress hosting/workflows

These usually favor many independent WordPress sites over one huge multisite network.

Option 3: One huge Multisite network

You can run:

mainnetwork.com
 ├── client1.mainnetwork.com
 ├── client2.mainnetwork.com
 ├── client3.mainnetwork.com

or map domains:

clientone.com
clienttwo.com
clientthree.com

Pros:

• One WordPress core install
• One update process
• Shared themes/plugins
• Easy creation of new microsites

Cons:

• All clients share the same database
• Network admin has access to everything
• Plugin conflicts affect everyone
• Harder to separate billing/security/backups

I’d only use this if all microsites are essentially part of the same organization.

Hosting stack I’d consider

For a serious multi-client setup:

VPS / dedicated server

• Hetzner
• DigitalOcean
• Vultr
• Linode

Typical stack:

• Ubuntu LTS
• Nginx or OpenLiteSpeed
• PHP 8.3+
• MariaDB/MySQL
• Redis object cache
• Cloudflare DNS/CDN
• Automated backups

For WordPress-heavy hosting, OpenLiteSpeed + LiteSpeed Cache is often a very performant combination.

Server layout example

For 50–200 microsites, I’d probably do:

/var/www/
 ├── network-client-a/
 │    ├── WordPress Multisite
 │    └── client sites
 │
 ├── network-client-b/
 │    ├── WordPress Multisite
 │    └── client sites
 │
 └── network-client-c/
      ├── WordPress Multisite
      └── client sites

Each network gets:

• separate database
• separate PHP pool
• separate backups
• separate staging environment

Tools that help

• WP-CLI — automate installs, cloning, updates
• Duplicator Pro — migrations/backups
• UpdraftPlus — backups
• Cloudflare — DNS, SSL, caching, protection

My default recommendation

For an agency hosting client microsites:

Small (5–25 clients):

• One VPS
• Separate WordPress Multisite install per client
• WP-CLI automation
• Cloudflare in front

Medium (25–200 clients):

• Multiple VPS instances
• Containerized WordPress stacks (Docker)
• Separate DBs
• Central monitoring/backups

Large (200+ microsites):

• Consider a WordPress hosting platform architecture rather than a single server.

If you tell me roughly how many microsites, whether clients need their own logins/admin access, and your expected traffic, I can suggest a more specific architecture (server size, database layout, and whether multisite is even the right fit).

If you mean multiple separate WordPress Multisite networks, each containing several client microsites, on a single server, I’d structure it like this:

Recommended stack

• Ubuntu/Debian VPS
• Nginx or OpenLiteSpeed as the web server
• PHP-FPM with a dedicated PHP pool per network/client group
• MariaDB/MySQL
• Redis for object caching
• WP-CLI for provisioning/maintenance
• Let’s Encrypt for SSL
• Cloudflare for DNS/CDN/WAF
• Docker if you want clean isolation and reproducible deployments

The important architectural choice is how you isolate the networks.

For a hosting business, I'd use

                    Cloudflare
                        │
                  ┌─────▼─────┐
                  │   Nginx   │
                  └─────┬─────┘
                        │
        ┌───────────────┼────────────────┐
        │               │                │
   Network A       Network B        Network C
   clients 1–20    clients 21–40   clients 41–60
        │               │                │
     PHP-FPM          PHP-FPM          PHP-FPM
        │               │                │
     MySQL DB         MySQL DB         MySQL DB
        │               │                │
      Redis            Redis            Redis

I'd generally give each Multisite network its own database, rather than putting every network into one enormous database. Within a network, WordPress naturally has separate tables for each site.

For example:

network-a.example
 ├── client1.com
 ├── client2.com
 └── client3.com

network-b.example
 ├── client4.com
 ├── client5.com
 └── client6.com

But there's an even better option in some cases

If these are client microsites that you manage centrally, you may not actually want multiple Multisite networks.

A single Multisite network can handle:

your-platform.com
 ├── client-a.com
 ├── client-b.com
 ├── client-c.com
 ├── client-d.com
 └── ...

That's substantially easier to operate: one WordPress core, one update process, centralized plugins/themes, centralized backups, etc.

I'd choose multiple networks when you specifically need stronger administrative/plugin/theme/data separation between groups of sites.

If you tell me roughly how many networks and total sites (e.g. 5 networks × 20 sites = 100 microsites), I can recommend the server architecture, database layout, and whether I'd use Docker, Nginx, or something like SpinupWP/RunCloud/Ploi.

If you mean multiple client microsites where each client gets their own WordPress site/network, I would usually not put all clients into one giant WordPress Multisite network. It depends on your business model.

There are three common architectures:

Option 1 — One WordPress Multisite network (best for true microsites)

Use when: all sites are related (franchise locations, departments, campaigns, regional sites, product microsites).

Stack:

• VPS/cloud server
• Nginx or LiteSpeed
• PHP-FPM
• MariaDB/MySQL
• Redis object cache
• Cloudflare CDN/WAF
• WP-CLI for management
• Backup system with off-server storage

Example:

example.com
 ├── client-a.example.com
 ├── client-b.example.com
 ├── client-c.example.com

or mapped domains:

clienta.com
clientb.com
clientc.com

Pros:

• One core install
• One theme/plugin update cycle
• Easy cloning
• Lower hosting cost

Cons:

• One bad plugin/theme update can affect everyone
• Client isolation is weaker
• Database grows into one large shared environment

WordPress Multisite specifically shares a codebase and database structure, so resource planning and isolation matter more as the network grows. topsyde.com

Option 2 — Separate WordPress installs on one host (my usual recommendation for agencies)

Use when: these are paying clients and you want clean separation.

Example:

/var/www/
 ├── client-a/
 ├── client-b/
 ├── client-c/

Each gets:

• its own database
• its own Linux user
• its own PHP-FPM pool
• its own backups
• its own staging

A good agency stack looks like:

Server

• Hetzner / DigitalOcean / Vultr / AWS Lightsail

Management

• RunCloud
• CloudPanel
• Plesk
• SpinupWP
• GridPane

WordPress tools

• WP-CLI
• MainWP or ManageWP for updates
• UpdraftPlus/BlogVault/Buddy backup
• Cloudflare

This avoids the "one client's plugin breaks every client's site" problem. Agency hosting setups commonly emphasize per-site isolation, separate users, and independent PHP processes for this reason. cloudstick.io

Option 3 — Managed WordPress platform

Use when: you want less server administration.

Good choices:

• WP Engine — strong agency workflow, staging, client handoff features. www.findbestwebhosting.com
• Kinsta — premium WordPress-focused infrastructure. northiscale.com
• Cloudways — flexible if you want your own cloud provider underneath. cloudpipelines.com

What I would build for a small/medium web agency

For 10–100 client microsites, I would do:

Cloud VPS
    |
    ├── Nginx
    ├── PHP 8.3 + PHP-FPM
    ├── MariaDB
    ├── Redis
    ├── Cloudflare
    |
    ├── client1.com (WP install)
    ├── client2.com (WP install)
    ├── client3.com (WP install)

Management layer:

RunCloud / GridPane / SpinupWP
          +
MainWP
          +
WP-CLI

Then create a template site:

• your starter theme
• standard plugins
• security settings
• SEO setup
• caching
• analytics

Clone that for each new client.

When I would actually use Multisite

I would choose Multisite if:

• you own/manage all sites
• they share the same design system
• they need synchronized updates
• clients do not need full admin freedom

Examples:

• 50 restaurant location sites
• school district sites
• franchise sites
• city/campaign landing pages

I would avoid Multisite for:

• unrelated client websites
• WooCommerce clients
• sites with custom plugins
• clients who need full admin control

If you tell me roughly how many microsites (5, 50, 500), traffic level, and whether clients need their own WP admin access, I can suggest a more exact stack and server size.

If you mean multiple independent WordPress Multisite networks, each containing client microsites, I’d avoid putting everything into one giant Multisite network.

My preferred setup

One VPS/server → Docker → one WordPress Multisite stack per client group/network

For example:

                    ┌── Nginx / Traefik
                    │
                    ├── Network A
                    │    ├── client1.com
                    │    ├── client2.com
                    │    └── client3.com
                    │
                    ├── Network B
                    │    ├── client4.com
                    │    └── client5.com
                    │
                    └── Network C
                         ├── client6.com
                         └── client7.com

Each network gets:

• its own WordPress installation
• its own database
• its own wp-content
• its own plugin/theme set
• independent WordPress updates
• independent backups/restores
• domain mapping for client domains
• PHP-FPM/container isolation

This is much safer operationally than putting every client's microsite into a single Multisite network. WordPress itself describes the fundamental distinction as one Multisite installation sharing a database versus multiple independent WordPress instances/databases. WordPress Developer Resources

Stack I'd use

For a more traditional non-containerized setup, Nginx + PHP-FPM + MariaDB + WP-CLI is also excellent. WordPress officially documents Nginx Multisite configurations. WordPress Developer Resources

The important architectural decision

If these are client microsites, I'd organize them like this:

Server
│
├── wp-network-client-sites
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── wp-network-agency-sites
│   ├── project-a.com
│   └── project-b.com
│
└── wp-network-internal
    ├── staging...
    └── demos...

Rather than:

One Multisite
├── Client A
├── Client B
├── Client C
├── Client D
├── Client E
└── ...

The latter gives you a very convenient centralized admin, but it also creates a large blast radius. A bad plugin, database issue, WordPress update, or compromised super-admin account can potentially affect the whole network.

WordPress Multisite deliberately shares core files, plugins/themes, and a database across the network, while individual sites have separate content tables. WordPress Developer Resources WordPress Developer Resources

When I'd use one giant Multisite

I'd use one network if:

• you control all the sites
• they're highly standardized
• they use the same theme/plugin ecosystem
• you want centralized management
• clients don't need strong isolation
• you're comfortable with one network-wide upgrade lifecycle

And domain mapping is now built into WordPress Multisite, so client-a.com, client-b.com, etc. can point at sites inside the network without needing the old domain-mapping plugin approach. WordPress Developer Resources

When I'd use separate Multisites

I'd strongly favor separate networks if:

• clients have different plugin requirements
• you want to give clients different levels of access
• some clients may eventually leave your hosting
• you want to restore one client's entire environment independently
• some sites are higher-risk than others
• you expect 50–500+ microsites
• you want to upgrade/test networks independently

You can still get most of the operational convenience through Docker/Compose and WP-CLI.

If you're building this as an agency hosting platform, my sweet spot would be: one VPS/cluster + Docker + multiple independent Multisite networks + Traefik + MariaDB + Redis + S3 backups.

If you tell me roughly how many microsites (e.g. 20, 100, 500), whether each client gets their own domain, and whether clients get WP admin access, I can lay out a concrete architecture—including directory structure, Docker Compose, database strategy, DNS/SSL, backups, and how I'd size the server.

One Multisite
├── Client A
├── Client B
├── Client C
├── Client D
├── Client E
└── ...

The latter gives you a very convenient centralized admin, but it also creates a large blast radius. A bad plugin, database issue, WordPress update, or compromised super-admin account can potentially affect the whole network.

WordPress Multisite deliberately shares core files, plugins/themes, and a database across the network, while individual sites have separate content tables.

When I'd use one giant Multisite

I'd use one network if:

If you mean one physical host running several independent WordPress Multisite networks, I’d generally not use one giant “multi-network” WordPress installation for a client microsite business.

My preferred architecture

Run one WordPress Multisite installation per client/network, all on the same server:

                    ┌── Nginx
                    │
                    ├── PHP-FPM
                    │
                    └── Host
                        │
                        ├── /srv/wp/client-a/
                        │     └── Multisite
                        │         ├── client-a.com
                        │         ├── campaign.client-a.com
                        │         └── ...
                        │
                        ├── /srv/wp/client-b/
                        │     └── Multisite
                        │         ├── client-b.com
                        │         └── ...
                        │
                        └── /srv/wp/client-c/
                              └── Multisite

WordPress officially supports multiple independent installations, and each Multisite network can contain multiple sites while sharing its WordPress core/plugins/themes and database. WordPress Developer Resources WordPress Developer Resources

For an agency/client setup, this gives you a much better blast-radius boundary:

• Client A's network can have its own plugins/themes.
• A broken plugin update doesn't necessarily take down every client's sites.
• You can give each client/network different administrators.
• Each network can have its own domain structure.
• You can back up/restore a client independently.
• You can upgrade networks at different times.
• A client's weird legacy plugin doesn't have to coexist with everyone else's stack.

I'd use something like Nginx + PHP-FPM + MariaDB/MySQL, with each network having its own database. Nginx has official Multisite configuration guidance, including domain/subdomain networks. WordPress Developer Resources Current WordPress requirements recommend PHP 8.3+ and MySQL 8.0+ or MariaDB 10.11+. WordPress.org

When I'd use one "multi-network" installation

There is a WordPress approach where you have:

One WP installation
       │
       ├── Network A
       │    ├── Site 1
       │    └── Site 2
       │
       ├── Network B
       │    ├── Site 3
       │    └── Site 4
       │
       └── Network C
            ├── Site 5
            └── Site 6

The WP Multi Network plugin exposes this functionality. It turns a Multisite installation into multiple networks while maintaining a global user set. WordPress.org GitHub

That's interesting if you are operating all of the networks yourself and want centralized administration.

But I'd be cautious about making it the foundation of a client hosting platform. The plugin's own documentation notes some complications around uploads and network configuration. WordPress.org

For client microsites, I'd probably choose

The key question is whether "network" means a client or whether "site" means a client.

If each client might have, say, 5–50 microsites, I'd seriously consider:

                One VPS / dedicated host
                         │
              ┌──────────┼──────────┐
              │          │          │
           Client A   Client B   Client C
           Multisite  Multisite  Multisite
              │          │          │
            10 sites    25 sites    8 sites

That's a very clean agency architecture.

If you're talking about hundreds/thousands of microsites, though, I'd design the hosting layer differently—especially around database layout, Redis/object caching, PHP-FPM pools, backups, deployment, domain provisioning, and tenant isolation.

If you tell me roughly how many clients/sites you're expecting (e.g. 20, 200, 2,000) and whether you're using a VPS, bare metal, or Kubernetes, I can sketch the architecture I'd use, including Nginx, PHP-FPM, databases, Redis, backups, and automated site provisioning.

If you mean multiple independent WordPress Multisite networks on one physical/VPS host—e.g. you have several clients and want each client to have their own network of microsites—I’d avoid trying to cram everything into one giant Multisite installation.

My preferred architecture

                    ┌── Nginx / Caddy
                    │
          ┌─────────┴─────────┐
          │                   │
     Client A             Client B
   WP Multisite          WP Multisite
   /var/www/a             /var/www/b
       │                     │
   PHP-FPM pool A         PHP-FPM pool B
       │                     │
   MySQL DB A             MySQL DB B

Each client gets:

• Separate WordPress installation
• Separate database
• Separate PHP-FPM pool (ideally)
• Their own Multisite network
• Their own domains/microsites
• Shared server-level Nginx/Caddy, PHP, Redis, MariaDB/MySQL, backups, etc.

That's substantially easier to isolate, back up, migrate, troubleshoot, and eventually move a client to another server. WordPress itself distinguishes between a Multisite network and multiple independent WordPress instances, and Multisite sites within a network share the installation/code and database infrastructure. WordPress Developer Resources WordPress Developer Resources

What I'd run

For a serious self-hosted setup:

Ubuntu/Debian + Nginx + PHP-FPM + MariaDB + Redis

Then something like:

/var/www/
    client-a/
        current/
        shared/
    client-b/
        current/
        shared/
    client-c/
        current/
        shared/

Each directory contains a normal WordPress installation configured as Multisite.

I'd put Nginx in front, with PHP-FPM pools separated by client. WordPress officially supports Nginx and provides Multisite-specific configuration examples. WordPress Developer Resources

For example:

client-a.com
microsite1.client-a.com
microsite2.client-a.com
        │
        ▼
    Nginx
        │
        ▼
  PHP-FPM pool A
        │
        ▼
  WordPress A
        │
        ▼
    Database A

And:

client-b.com
site1.client-b.com
site2.client-b.com
        │
        ▼
    Nginx
        │
        ▼
  PHP-FPM pool B
        │
        ▼
  WordPress B
        │
        ▼
    Database B

Why I wouldn't use "multiple networks in one WordPress"

There actually is a way to do this. The relatively obscure WP Multi Network project exposes WordPress's underlying multi-network functionality and lets one WordPress installation contain multiple Multisite networks. GitHub WordPress.org English (UK)

So you could theoretically have:

ONE WordPress
   │
   ├── Network A
   │     ├── Site 1
   │     ├── Site 2
   │     └── Site 3
   │
   ├── Network B
   │     ├── Site 4
   │     └── Site 5
   │
   └── Network C
         ├── Site 6
         └── Site 7

But for a client hosting platform, I wouldn't make that my default. You're increasing the blast radius considerably: shared core/plugins/code/database infrastructure means a bad plugin, upgrade, configuration change, or resource spike can potentially affect unrelated clients.

If these are your own microsites

There's a different answer.

If you're talking about your agency running lots of relatively similar microsites, rather than giving clients administrative ownership, I'd consider:

One Multisite network per logical customer/group, rather than one network per microsite.

For example:

Server
│
├── Network: Franchise Client A
│     ├── location-1
│     ├── location-2
│     ├── location-3
│     └── location-4
│
├── Network: Franchise Client B
│     ├── location-1
│     ├── location-2
│     └── location-3
│
└── Network: Internal/Marketing
      ├── campaign-1
      ├── campaign-2
      └── campaign-3

That's a very reasonable use of Multisite because the sites genuinely share themes/plugins/code and can be administered together. WordPress specifically describes Multisite as useful when sites share resources such as themes and plugins. WordPress Developer Resources

The stack I'd choose in 2026

For a VPS/bare-metal host, I'd probably use:

• Nginx
• PHP 8.3/8.4 + PHP-FPM
• MariaDB 11.x or MySQL 8.x
• Redis for object caching
• Let's Encrypt certificates
• Cloudflare in front if appropriate
• WP-CLI
• Composer where your projects warrant it
• Git/deployment system
• Automated database + uploads backups
• Monitoring with per-client resource visibility
• One PHP-FPM pool per client/network if the client isolation is important

And I'd automate provisioning so creating a new client looks roughly like:

new-client client-a

which creates:

DNS
vhost
SSL
database
database user
PHP-FPM pool
WordPress
Multisite
Redis configuration
backup configuration
monitoring

rather than manually maintaining dozens of installations.

Bottom line: if these are genuinely separate clients, I'd choose multiple independent Multisite installations on one host, not WordPress's obscure multi-network capability. You still get the efficiency of Multisite for each client while keeping failures and administration reasonably isolated.

If you tell me roughly how many clients/sites you're expecting (e.g. 10 clients × 20 microsites) and whether this is Docker or bare-metal/VPS, I can lay out a concrete architecture—including Nginx, PHP-FPM pools, DB layout, Redis, backups, and deployment.

And:

client-b.com
site1.client-b.com
site2.client-b.com
        │
        ▼
    Nginx
        │
        ▼
  PHP-FPM pool B
        │
        ▼
  WordPress B
        │
        ▼
    Database B

Why I wouldn't use "multiple networks in one WordPress"

There actually is a way to do this. The relatively obscure WP Multi Network project exposes WordPress's underlying multi-network functionality and lets one WordPress installation contain multiple Multisite networks. GitHub WordPress.org English (UK)

So you could theoretically have:

ONE WordPress
   │
   ├── Network A
   │     ├── Site 1
   │     ├── Site 2
   │     └── Site 3
   │
   ├── Network B
   │     ├── Site 4
   │     └── Site 5
   │
   └── Network C
         ├── Site 6
         └── Site 7

But for a client hosting platform, I wouldn't make that my default. You're increasing the blast radius considerably: shared core/plugins/code/database infrastructure means a bad plugin, upgrade, configuration change, or resource spike can potentially affect unrelated clients.

If these are your own microsites

There's a different answer.

If you're talking about your agency running lots of relatively similar microsites, rather than giving clients administrative ownership, I'd consider:

One Multisite network per logical customer/group, rather than one network per microsite.

For example:

Server
│
├── Network: Franchise Client A
│     ├── location-1
│     ├── location-2
│     ├── location-3
│     └── location-4
│
├── Network: Franchise Client B
│     ├── location-1
│     ├── location-2
│     └── location-3
│
└── Network: Internal/Marketing
      ├── campaign-1
      ├── campaign-2
      └── campaign-3

That's a very reasonable use of Multisite because the sites genuinely share themes/plugins/code and can be administered together. WordPress specifically describes Multisite as useful when sites share resources such as themes and plugins.

The stack I'd choose in 2026

For a VPS/bare-metal host, I'd probably use:

If you mean “I want one physical/virtual host to run multiple separate WordPress Multisite networks, each containing a bunch of client microsites”, I’d avoid trying to cram everything into one giant Multisite.

What I’d use

Nginx + PHP-FPM + MariaDB/MySQL + Bedrock + Trellis, with one WordPress/Bedrock installation per client network.

Something like:

Server
│
├── Network A — Client/Brand A
│   ├── client-a.com
│   ├── product-a.com
│   └── campaign-a.com
│
├── Network B — Client/Brand B
│   ├── client-b.com
│   ├── microsite-1.com
│   └── microsite-2.com
│
└── Network C — Client/Brand C
    ├── client-c.com
    └── campaign-c.com

Each network gets its own:

• WordPress core
• database
• plugins/themes
• wp-content
• uploads
• Redis/object cache namespace
• deployment pipeline
• backups
• client-level isolation

But they can all live on the same VPS/dedicated server. Trellis specifically supports managing multiple WordPress sites on a single server. Roots

Why I prefer this over one giant network

WordPress Multisite is excellent when the sites are genuinely part of the same organization/ecosystem. Sites within a network share the WordPress installation, plugins/themes, and user table, while having separate site tables/content. WordPress Developer Resources WordPress Developer Resources

For client hosting, however, I'd usually want:

client A network ≠ client B network

rather than:

EVERY client
   ↓
one enormous WP multisite

That gives you a much cleaner failure/security/deployment boundary. If Client A needs a weird plugin, custom PHP, or a major upgrade, you're not potentially putting every other client's microsite at risk.

My preferred stack

Bedrock is particularly nice here because it makes WordPress a Composer-managed application and keeps configuration/environment variables separate from the codebase. Its current server documentation supports PHP 8.3+ and Nginx, with the web root pointed at Bedrock's web directory. Roots

Trellis then gives you a fairly clean way to provision and manage multiple Bedrock sites on the same machine. Roots

One important distinction

If by “multiple multisite networks” you literally mean:

I want 10 independent Multisite networks running from one WordPress codebase/database, with each network having its own domains.

That's a different architecture.

There is a plugin called WP Multi Network that exposes WordPress's underlying ability to have multiple networks, allowing sites to be grouped into separate networks with different domains/paths. WordPress.org

I'd consider that for something like:

one WordPress installation
        │
        ├── Network 1
        │    ├── site
        │    ├── site
        │    └── site
        │
        ├── Network 2
        │    ├── site
        │    └── site
        │
        └── Network 3
             ├── site
             └── site

But I wouldn't make that my default architecture for a client microsite hosting business. It creates a pretty unusual WordPress installation and introduces additional complexity around uploads, cookies, network administration, migrations, backups, etc. The plugin itself notes special handling around uploads for multiple networks. WordPress.org

The architecture I'd actually deploy

For, say, 50–200 client microsites, I'd lean toward:

                         Cloudflare
                             │
                       ┌─────┴─────┐
                       │   Nginx   │
                       └─────┬─────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
         PHP-FPM pool   PHP-FPM pool   PHP-FPM pool
              │              │              │
       ┌──────┴─────┐ ┌──────┴─────┐ ┌──────┴─────┐
       │ Network A  │ │ Network B  │ │ Network C  │
       │ Bedrock    │ │ Bedrock    │ │ Bedrock    │
       │ Multisite  │ │ Multisite  │ │ Multisite  │
       └──────┬─────┘ └──────┬─────┘ └──────┬─────┘
              │              │              │
             DB             DB             DB

You can still share the server, Nginx, PHP infrastructure, Redis server, monitoring, and deployment tooling without sharing the actual WordPress application/database between clients.

If the microsites are all essentially clones

There's another architecture I'd seriously consider: one Multisite network per “platform” rather than per client.

For example:

Network: Real Estate Platform
 ├── realtor1.com
 ├── realtor2.com
 ├── realtor3.com
 └── realtor4.com

Network: Restaurant Platform
 ├── restaurant1.com
 ├── restaurant2.com
 └── restaurant3.com

That's where Multisite really shines: common plugins/themes, common deployment, common functionality, and lots of sites sharing the same underlying application. Domain mapping is built into modern WordPress Multisite, so individual subsites can use their own domains. WordPress Developer Resources

My rule of thumb:

• Same product/platform → one Multisite network
• Different clients with materially different requirements → separate Multisite networks
• Completely independent clients → separate WordPress installs
• Many networks on one server → Trellis/Bedrock + Nginx
• Don't use WP Multi Network unless you specifically need multiple networks inside one WP installation

If you tell me roughly how many clients/sites you're expecting (e.g. 20, 100, 500) and whether the microsites are all using the same theme/plugins, I can sketch the exact server/database/Nginx/Redis architecture I'd use, including how I'd isolate clients and handle wildcard/custom domains.

For client hosting, however, I'd usually want:

client A network ≠ client B network

rather than:

EVERY client
   ↓
one enormous WP multisite

That gives you a much cleaner failure/security/deployment boundary. If Client A needs a weird plugin, custom PHP, or a major upgrade, you're not potentially putting every other client's microsite at risk.

My preferred stack

Bedrock is particularly nice here because it makes WordPress a Composer-managed application and keeps configuration/environment variables separate from the codebase. Its current server documentation supports PHP 8.3+ and Nginx, with the web root pointed at Bedrock's web directory. Roots

Trellis then gives you a fairly clean way to provision and manage multiple Bedrock sites on the same machine. Roots

One important distinction

If by “multiple multisite networks” you literally mean:

I want 10 independent Multisite networks running from one WordPress codebase/database, with each network having its own domains.

That's a different architecture.

There is a plugin called WP Multi Network that exposes WordPress's underlying ability to have multiple networks, allowing sites to be grouped into separate networks with different domains/paths. WordPress.org

I'd consider that for something like:

one WordPress installation
        │
        ├── Network 1
        │    ├── site
        │    ├── site
        │    └── site
        │
        ├── Network 2
        │    ├── site
        │    └── site
        │
        └── Network 3
             ├── site
             └── site

But I wouldn't make that my default architecture for a client microsite hosting business. It creates a pretty unusual WordPress installation and introduces additional complexity around uploads, cookies, network administration, migrations, backups, etc. The plugin itself notes special handling around uploads for multiple networks. WordPress.org

The architecture I'd actually deploy

For, say, 50–200 client microsites, I'd lean toward:

                         Cloudflare
                             │
                       ┌─────┴─────┐
                       │   Nginx   │
                       └─────┬─────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
         PHP-FPM pool   PHP-FPM pool   PHP-FPM pool
              │              │              │
       ┌──────┴─────┐ ┌──────┴─────┐ ┌──────┴─────┐
       │ Network A  │ │ Network B  │ │ Network C  │
       │ Bedrock    │ │ Bedrock    │ │ Bedrock    │
       │ Multisite  │ │ Multisite  │ │ Multisite  │
       └──────┬─────┘ └──────┬─────┘ └──────┬─────┘
              │              │              │
             DB             DB             DB

You can still share the server, Nginx, PHP infrastructure, Redis server, monitoring, and deployment tooling without sharing the actual WordPress application/database between clients.

If the microsites are all essentially clones

There's another architecture I'd seriously consider: one Multisite network per “platform” rather than per client.

For example:

If you mean several independent WordPress Multisite networks, each containing multiple client microsites, I’d avoid trying to cram everything into one giant Multisite installation.

My preferred architecture

                         ┌── Network A ── client1.com
Internet → Nginx/Proxy ──┤              ├─ client2.com
                         │              └─ client3.com
                         │
                         ├── Network B ── client4.com
                         │              ├─ client5.com
                         │              └─ client6.com
                         │
                         └── Network C ── client7.com
                                        └─ client8.com

I'd use:

• Nginx as the web server/reverse proxy
• PHP-FPM for PHP execution
• MariaDB/MySQL, preferably with a separate database per network
• One WordPress codebase per network
• WordPress Multisite inside each codebase
• WP-CLI for provisioning/maintenance
• Redis object cache if the number of sites warrants it
• Cloudflare or another CDN/WAF in front
• Automated backups to off-host storage
• Git/deployment tooling for your themes and mu-plugins

WordPress officially supports Multisite networks where sites share the same WordPress core, plugins and themes while maintaining separate site data/tables. WordPress Developer Resources

Why multiple networks instead of one huge network?

For a client-microsite business, network boundaries are valuable.

For example:

/var/www/
    network-a/
        wordpress/
        wp-content/
    network-b/
        wordpress/
        wp-content/
    network-c/
        wordpress/
        wp-content/

Each network can have its own:

• plugins
• themes
• PHP configuration
• database
• update schedule
• staging environment
• backups
• client group
• security boundary

If one client's plugin causes problems, you're not necessarily taking down every other client.

Conversely, don't create a separate WordPress installation for every tiny microsite unless you actually need that isolation. Multisite is specifically designed to let multiple sites share one installation. WordPress Developer Resources

Domain mapping makes this particularly nice

A network could internally look like:

network-a.internal
├── site1
├── site2
└── site3

while the public sites are:

client-one.com
client-two.com
client-three.com

Modern WordPress has native domain mapping—you don't need the old domain-mapping plugin approach. WordPress Developer Resources

Nginx can also handle the wildcard/subdomain side of Multisite; WordPress's documentation provides Nginx configurations for Multisite. WordPress Developer Resources

Provisioning

This is where I'd lean heavily on WP-CLI.

You can script things like:

wp core multisite-install ...
wp site create --slug=client-one ...
wp site create --slug=client-two ...
wp plugin install ...
wp theme enable ...

WP-CLI explicitly supports managing Multisite networks and creating individual sites, including specifying the network ID. WordPress Developer Resources WordPress Developer Resources

So your provisioning flow could ultimately be:

new client
    ↓
create network/site
    ↓
DNS
    ↓
SSL
    ↓
WP-CLI provisioning
    ↓
install standard theme/mu-plugins
    ↓
import starter content
    ↓
client receives login

One important distinction

If by "multiple WP multisite networks" you actually mean hundreds of microsites, I'd design this somewhat differently.

I'd probably use:

Nginx → PHP-FPM → multiple isolated WP Multisite installations → shared Redis + DB server

rather than:

Nginx → one enormous WordPress Multisite containing everything.

The former gives you a much better failure/update boundary while still getting most of the operational efficiency of Multisite.

If you tell me roughly how many networks/sites you're expecting (e.g. 5 networks × 20 sites, or 50 × 100) and whether this is a VPS, dedicated server, or Kubernetes/Docker setup, I can lay out a concrete production architecture—including Nginx, PHP-FPM pools, MySQL/MariaDB, Redis, filesystem layout, backups, and automated client-site provisioning.

If you mean one physical/virtual server hosting several separate WordPress Multisite networks, each containing multiple client microsites, I’d avoid trying to make one giant Multisite installation do everything.

My preferred architecture

One VPS → Nginx → multiple independent WordPress Multisite installations

For example:

                         VPS
                          │
                    ┌─────┴─────┐
                    │   Nginx   │
                    └─────┬─────┘
                          │
          ┌───────────────┼────────────────┐
          │               │                │
       Network A       Network B        Network C
       /wp-a           /wp-b            /wp-c
          │               │                │
     ┌────┼────┐     ┌────┼────┐      ┌───┼────┐
   Client 1  2       Client 3  4       Client 5 6

Each network gets its own WordPress files + database, while the server infrastructure is shared.

That's considerably cleaner for client work than putting every client into one enormous network. WordPress itself distinguishes between a Multisite network (one WP installation with multiple sites) and multiple independent WordPress instances. WordPress Developer Resources WordPress Developer Resources

What I'd use

• Ubuntu/Debian VPS
• Nginx
• PHP-FPM
• MariaDB/MySQL
• Redis
• WP-CLI
• Let's Encrypt
• Cloudflare DNS/proxy, if appropriate
• A management layer such as RunCloud if you don't want to maintain Nginx/PHP/server configuration manually.

runcloud.io is particularly interesting for this use case because its WordPress tooling supports Multisite, network-site switching, cache management, and multiple domains. RunCloud Website RunCloud Website

Why I wouldn't use "multiple networks" inside one Multisite

There is a plugin called wordpress.org that exposes WordPress's underlying ability to have multiple networks within a Multisite installation. It can group sites into separate networks and share a global user system. WordPress.org English (UK) GitHub

It's clever, but for client hosting, I'd be cautious.

You end up with something like:

ONE WordPress installation
        │
   WP Multi Network
        │
 ┌──────┼────────┐
Network A       Network B
    │               │
 clients           clients

The blast radius is much larger. A core/plugin/PHP/database problem at the installation level potentially affects every client network.

With independent installations:

Network A ── DB A ── Client A1/A2/A3
Network B ── DB B ── Client B1/B2
Network C ── DB C ── Client C1/C2

you get much better isolation.

The important distinction

If your clients are mostly microsites that share the same theme/plugins/codebase, I'd actually go one step further:

Option A — One Multisite per "product"

For example:

microsites.youragency.com
├── client-a.com
├── client-b.com
├── client-c.com
└── client-d.com

One Multisite network is ideal when those sites genuinely share infrastructure. WordPress explicitly supports mapping individual subsites to their own domains. WordPress Developer Resources

Option B — Separate Multisite per client group

If you have different groups of clients:

VPS
├── franchise-sites
│   ├── site 1
│   ├── site 2
│   └── site 3
│
├── nonprofit-sites
│   ├── site 4
│   └── site 5
│
└── marketing-sites
    ├── site 6
    └── site 7

This is probably the sweet spot for an agency.

Option C — Completely independent WordPress

For high-value clients or clients who need unusual plugins, WooCommerce, custom code, staging, etc., give them their own WP installation.

That gives you:

shared server → isolated application → isolated database → isolated client

rather than putting everything into one Multisite.

What I'd choose for your situation

If you're building a client microsite hosting platform, I'd probably do:

Ubuntu + Nginx + PHP-FPM + MariaDB + Redis + WP-CLI + RunCloud, with one independent Multisite installation per client cohort.

Then use domain mapping so each microsite can live on its client's actual domain. WordPress has native domain mapping support in current versions. WordPress Developer Resources

For example:

                         VPS
                          │
                       Nginx
                          │
        ┌─────────────────┼──────────────────┐
        │                 │                  │
    MS Network 1      MS Network 2       Standalone WP
    restaurants       real-estate        VIP client
        │                 │
   ┌────┼────┐        ┌───┼────┐
   A    B    C        D   E    F

That gives you a nice balance of economics, centralized maintenance, client isolation, and flexibility.

If you tell me roughly how many microsites (10 / 50 / 200+), whether each client gets their own domain, and whether clients need WP-admin access, I can recommend the exact server architecture (CPU/RAM/storage, Nginx layout, DB strategy, backups, Redis, Cloudflare, and deployment/update workflow).

If you mean one physical/VPS host running multiple separate WordPress Multisite networks, I’d avoid trying to cram all clients into one giant Multisite. I’d use multiple isolated WordPress installations, each potentially being its own Multisite network.

What I’d use

A solid agency setup would be:

• Ubuntu/Debian VPS
• Nginx
• PHP-FPM
• MariaDB/MySQL
• Redis object cache
• WP-CLI
• Cloudflare for DNS/CDN/WAF
• One WordPress installation per client/network
• Docker Compose if you want clean isolation and repeatable deployments

WordPress officially supports Multisite as multiple sites sharing one installation/codebase, but a Multisite network also shares plugins/themes and has a shared database/user infrastructure. WordPress Developer Resources Learn WordPress

For client microsites, I'd structure it something like:

Host
│
├── Network A
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   └── client-e.com
│
├── Network C
│   ├── client-f.com
│   ├── client-g.com
│   └── client-h.com
│
└── Management / backups / monitoring

Each network gets its own WP codebase + database, while sites inside that network share themes/plugins.

Why I prefer this

The big issue is blast radius.

If you put 50 unrelated clients into one Multisite:

one bad plugin, PHP problem, database issue, or compromised admin account can potentially affect the entire network.

With separate networks:

Network A dies
       ↓
Network B unaffected
Network C unaffected

You also get much cleaner client separation.

If you genuinely need multiple networks inside one WP installation

There is an interesting option: WP Multi Network.

wordpress.org

It exposes WordPress's underlying ability to have multiple Multisite networks around one global user set, with different domains and site arrangements. WordPress.org GitHub

But I'd consider that a specialized/advanced architecture, not my default recommendation for an agency hosting unrelated clients.

My preferred stack

For something you're actually going to operate commercially, I'd probably build:

Cloudflare
    │
    ▼
Nginx
    │
    ├── network1.example-host.com → PHP-FPM
    ├── network2.example-host.com → PHP-FPM
    └── network3.example-host.com → PHP-FPM
             │
             ▼
        WordPress
             │
        ┌────┴────┐
        ▼         ▼
     MariaDB    Redis

Nginx + PHP-FPM is a well-supported WordPress configuration, including Multisite-specific routing. WordPress Developer Resources

For the client domains, WordPress 4.5+ has native domain mapping, so a site can appear as client.com rather than client.network-host.com. WordPress Developer Resources

One important distinction

If your goal is:

"I want 100 small client websites that all use the same theme/plugins and I want to update them together."

→ One Multisite network is probably best.

If your goal is:

"I want several groups of clients, with each group having its own plugins/themes/admin boundary."

→ Multiple Multisite installations is what I'd choose.

If your goal is:

"I want to sell/manage WordPress microsites as a hosting platform, with automated provisioning, backups, SSL, domains, staging, updates, etc."

→ I'd go a step further and build a Docker + Nginx + PHP-FPM + MariaDB + Redis + WP-CLI provisioning platform, rather than relying on Multisite alone.

If you tell me roughly how many networks/sites you're expecting (e.g. 5 networks × 20 sites) and whether this is a single VPS or dedicated server, I can lay out the exact architecture I'd use, including filesystem, database, Nginx, PHP-FPM, backups, and domain/SSL strategy.

If you mean multiple WordPress Multisite networks (not just multiple sites inside one network) for client microsites on one physical host, I’d usually avoid putting unrelated clients into a single Multisite network. The better architecture depends on how much isolation you need.

WordPress Multisite itself is designed around a group of sites sharing one WordPress codebase, database, themes, and plugins. WordPress Developer Resources WordPress Developer Resources For an agency hosting client microsites, that shared dependency is often the biggest tradeoff.

Recommended setups

Option 1 — Multiple independent WordPress installs (best for most agencies)

My default recommendation for client work.

Stack:

• One VPS or dedicated server
• Nginx or Apache
• PHP-FPM
• MariaDB/MySQL
• Redis object cache
• Let's Encrypt SSL
• WP-CLI
• A management layer such as mainwp.com or managewp.com

Example:

/var/www/
  client-a.com/
    wordpress
    database_a

  client-b.com/
    wordpress
    database_b

  client-c.com/
    wordpress
    database_c

Advantages:

• Client A cannot break Client B through a bad plugin update
• Easier migrations
• Easier backups/restores
• Clients can have different plugins/themes
• Cleaner ownership boundaries

Disadvantages:

• More WordPress cores to update
• Slightly more storage

For a client hosting business, this is usually the safest long-term model. DCHost.com

Option 2 — Separate Multisite networks on one host

Good if you specifically want network-level separation.

Example:

Server
|
├── Network 1
│   ├── microsite-a
│   ├── microsite-b
│
├── Network 2
│   ├── microsite-c
│   ├── microsite-d

Each network gets:

• its own WordPress install
• its own database
• its own plugins/themes
• its own Super Admin

This is a reasonable compromise if you have groups of related clients.

Example:

• Network 1: restaurants
• Network 2: real estate agents
• Network 3: franchise locations

Option 3 — One giant Multisite network

Only use this if all sites are basically the same product.

Good examples:

• Franchise locations
• School departments
• Regional offices
• SaaS website builder

Bad examples:

• 50 unrelated small-business clients

The problem is blast radius:

• one broken plugin update affects everyone
• database growth affects everyone
• network migrations are harder
• separating one client later is painful

WordPress notes that Multisite sites share core files and network resources, so planning the network structure matters. WordPress Developer Resources

Server stack I would use today

For a small/medium agency:

VPS

• 8–16 GB RAM
• 4–8 CPU cores
• NVMe storage

Software

• Ubuntu LTS
• Nginx
• PHP 8.2/8.3
• MariaDB 10.6+
• Redis
• Fail2ban
• UFW firewall
• Automated backups

Deployment/management

Pick one:

• runcloud.io — easier server management
• gridpane.com — WordPress-focused hosting stack
• spinupwp.com — clean WordPress server management
• ploi.io — general PHP app/server management

My preferred agency architecture

For ~10–100 client microsites:

Cloud VPS
│
├── Nginx
│
├── PHP-FPM pools
│
├── Redis
│
├── MariaDB
│
├── client1.com
│     └── WordPress
│
├── client2.com
│     └── WordPress
│
├── client3.com
│     └── WordPress
│
└── Backups → S3-compatible storage

Then manage all installs centrally.

If you specifically want Multisite

I would do:

• One Multisite network per "customer family"
• Never mix unrelated paying clients
• Use domain mapping
• Use staging before network-wide updates
• Keep off-server backups

For example:

✅ agency-franchise-network.com

• 100 franchise sites

❌ myagency-multisite.com

• plumber client
• dentist client
• restaurant client
• lawyer client

If you tell me roughly how many microsites you expect (10, 50, 500+), whether clients need their own WP admin, and whether they share the same theme/plugins, I can suggest a more exact architecture and server size.

If you mean several independent WordPress Multisite networks, with each network containing multiple client microsites, I’d avoid trying to cram everything into one giant Multisite network.

What I’d use

One VPS/host → Docker Compose → separate WordPress Multisite stacks per network.

For example:

Host
├── Traefik / Nginx Proxy Manager
│
├── Network A
│   ├── WordPress
│   ├── MariaDB
│   └── Redis
│      ├── client-a.com
│      ├── client-b.com
│      └── client-c.com
│
├── Network B
│   ├── WordPress
│   ├── MariaDB
│   └── Redis
│      ├── client-d.com
│      └── client-e.com
│
└── Network C
    └── ...

WordPress Multisite is specifically designed to let multiple sites share one WordPress installation, including its plugins/themes, while each site has its own database tables/content. WordPress Developer Resources WordPress Developer Resources

The important distinction is:

• Microsites that should share code/plugins/themes: put them in the same Multisite network.
• Clients that need isolation, different plugin stacks, different PHP versions, or independent upgrades: put them in separate Multisite networks.
• A completely independent client application: use a separate WordPress instance rather than Multisite.

My preferred stack

For a serious client-hosting setup:

• Ubuntu/Debian VPS
• Docker + Docker Compose
• Traefik or Nginx as the reverse proxy
• PHP-FPM
• MariaDB/MySQL, preferably a separate DB per network
• Redis for object caching
• WP-CLI for provisioning/maintenance
• Automated backups to object storage
• Git-managed Compose/configuration
• Cloudflare DNS if appropriate

You don't actually need a special "multiple Multisite manager." Each Multisite installation is just an ordinary WordPress installation from the server's perspective. WordPress's own documentation explicitly describes multiple WordPress instances as an alternative to putting everything into one Multisite network. WordPress Developer Resources

Why I wouldn't use one massive Multisite

Suppose you have:

Agency
├── Network 1
│   ├── Client A
│   ├── Client B
│   └── Client C
├── Network 2
│   ├── Client D
│   └── Client E
└── Network 3
    └── Client F

That gives you a nice isolation boundary.

If Client A needs a plugin that Client B shouldn't have, you can keep them on separate networks. Likewise, you can upgrade/migrate Network 2 without touching Network 1.

A single network is much simpler operationally, though. If all your microsites use essentially the same stack, I'd probably do:

One VPS
└── One Multisite
    ├── client1.com
    ├── client2.com
    ├── client3.com
    ├── client4.com
    └── ...

Domain mapping is built into modern WordPress Multisite, so each subsite can use its own client domain. WordPress Developer Resources

One thing I'd especially recommend

Don't use a control panel like cPanel as the architecture for this unless you specifically need its UI.

For a developer-operated client platform, I'd rather have:

Docker
  ↓
Traefik
  ↓
WP Multisite containers
  ↓
MariaDB
  ↓
Redis
  ↓
S3-compatible backups

Then automate creating a new network/site with WP-CLI. WP-CLI has native commands for installing and converting Multisite networks. WordPress Developer Resources WordPress Developer Resources

If you tell me roughly how many networks/sites you're talking about (e.g. 5 networks × 20 microsites) and whether you have a VPS, dedicated server, or cloud VM, I can lay out the exact architecture—including Docker Compose, reverse proxy, SSL, DNS, database layout, backups, and how I'd provision a new client.

If you mean several separate WordPress Multisite networks, each containing client microsites, on one physical/virtual host, I’d use a containerized Nginx + PHP-FPM + MariaDB/MySQL setup, with one container/project per network.

My preferred architecture

                    Internet
                       │
                 Cloudflare / DNS
                       │
                 Nginx / Traefik
                       │
        ┌──────────────┼──────────────┐
        │              │              │
   Network A       Network B      Network C
   WordPress       WordPress      WordPress
   multisite       multisite      multisite
      │               │              │
   DB A            DB B           DB C

Each network gets:

• Its own WordPress codebase
• Its own database
• Its own uploads
• Its own wp-config.php
• Its own plugin/theme set
• Its own PHP-FPM/container resources
• Independent backups/restores

WordPress itself describes Multisite as multiple sites sharing one WordPress installation and database, so keeping different client groups in different networks gives you a useful isolation boundary. WordPress Developer Resources WordPress Developer Resources

Why I wouldn't put everything into one giant Multisite

For a client-microsite hosting business, I'd generally do something like:

• Network A: Client sites that share your agency's common stack
• Network B: Another group with a different theme/plugin stack
• Network C: Higher-value clients requiring more isolation
• Potentially single-site WordPress for clients that need complete independence

The biggest advantage is that a bad plugin update or customization on Network A doesn't automatically become a problem for Network B.

Within each network, you can still map individual client domains:

network-a.yourplatform.com
    ├── client1.com
    ├── client2.com
    ├── client3.com
    └── client4.com

network-b.yourplatform.com
    ├── client5.com
    ├── client6.com
    └── client7.com

WordPress has native domain mapping for Multisite, so a subsite can use its own top-level domain. WordPress Developer Resources

What I'd actually run

For a new setup in 2026, my stack would be:

Host

• Ubuntu/Debian VPS
• Docker + Compose
• Nginx Proxy Manager, Traefik, or plain Nginx
• Cloudflare DNS/CDN

Application

• WordPress
• PHP 8.x + PHP-FPM
• OPcache
• WP-CLI

Database

• MariaDB or MySQL
• Prefer one database per network, even if they're on the same DB server

Caching

• Redis object cache
• Cloudflare/page caching where appropriate
• PHP OPcache

Operations

• Automated backups
• Git for custom themes/plugins
• WP-CLI for provisioning
• Monitoring
• Separate staging environment

WordPress Multisite does require the appropriate rewrite/server configuration; Nginx is perfectly viable, although its configuration differs from Apache because it doesn't use .htaccess. WordPress Developer Resources Learn WordPress

One important distinction

If by "multiple multisite networks" you actually mean:

"I want 100–500 client microsites and I want to organize them into groups."

Then I would not necessarily create dozens of Multisite networks.

I'd probably use:

1–5 Multisite networks
        ↓
hundreds of client microsites

and choose the network boundaries based on plugin/theme requirements, security/isolation, maintenance windows, and who manages the clients.

If, however, clients need genuinely independent environments, I'd skip Multisite for those and run separate WordPress instances, still sharing the same host/infrastructure. WordPress explicitly supports the multiple-instance architecture, including separate databases per installation. WordPress Developer Resources

My recommendation

For an agency building a microsite platform, I'd start with:

Docker Compose + Nginx/Traefik + PHP-FPM + MariaDB + Redis + Cloudflare + WP-CLI, with one Compose project/database per Multisite network.

That's a much cleaner foundation than trying to make one enormous WordPress installation serve every client.

If you tell me roughly how many microsites (10 / 100 / 1,000+), VPS specs, and whether clients need their own WP admin, I can lay out the exact architecture—including filesystem, databases, Docker Compose, domain routing, SSL, backups, and a provisioning workflow.

If you mean several independent WordPress Multisite networks, each containing multiple client microsites, on one VPS/server, I’d avoid trying to put everything into one giant Multisite installation.

What I’d use

Ubuntu + Nginx + PHP-FPM + MariaDB/MySQL + WP-CLI, with one WordPress installation per client/network.

For example:

Server
├── network-client-a/
│   ├── WordPress Multisite
│   ├── client-a.com
│   ├── microsite1.client-a.com
│   └── microsite2.client-a.com
│
├── network-client-b/
│   ├── WordPress Multisite
│   ├── client-b.com
│   ├── microsite1.client-b.com
│   └── microsite2.client-b.com
│
└── network-client-c/
    ├── WordPress Multisite
    ├── client-c.com
    └── microsite1.client-c.com

WordPress explicitly supports multiple independent WordPress instances, and Multisite itself is a single WP installation containing multiple sites. WordPress Developer Resources WordPress Developer Resources

That architecture gives you a useful boundary:

• Network-level plugins/themes stay isolated to that client.
• One problematic client doesn't require you to take down every other client's network.
• You can give each network its own database.
• You can upgrade PHP per application if necessary.
• Backups/restores are much easier to reason about.
• Client A's Super Admin cannot administer Client B's network.
• You can eventually move a client's entire network to another server.

The management layer I'd put on top

If you don't want to maintain Nginx/PHP-FPM/server provisioning yourself, SpinupWP is probably my first choice for this particular setup.

It supports creating individual WordPress sites as Multisite installations, including subdomain and subdirectory networks. It also runs separate PHP-FPM pools for sites, which provides useful isolation, and its full-page Nginx caching is configured per site. SpinupWP

spinupwp.com

RunCloud is another good choice if you want a more general-purpose server control panel. It can deploy multiple WordPress applications on the same server and has API automation for deploying many sites. RunCloud

runcloud.io

My preferred stack

For a small agency hosting perhaps 10–50 client networks:

Hetzner / DigitalOcean / Vultr VPS
        │
        ├── Ubuntu
        │
        ├── Nginx
        │
        ├── PHP-FPM
        │      ├── network-a pool
        │      ├── network-b pool
        │      └── network-c pool
        │
        ├── MariaDB
        │      ├── wp_network_a
        │      ├── wp_network_b
        │      └── wp_network_c
        │
        ├── Redis
        │
        └── SpinupWP
                │
                └── WP-CLI

Then automate provisioning with WP-CLI. WP-CLI can install Multisite and create individual sites within a network, including assigning a site to a particular network. WordPress Developer Resources WordPress Developer Resources

For example, your provisioning script could conceptually do:

create-client-network client-a
create-client-site client-a microsite-one
create-client-site client-a microsite-two
configure-domains client-a
issue-ssl client-a
enable-cache client-a
schedule-backups client-a

You can also use WP-CLI aliases to manage installations remotely and consistently. WordPress Developer Resources

One important distinction

If by "multiple multisite networks" you actually mean something like:

I want 5 completely independent Multisite networks, each with 20–100 microsites

then yes, use multiple WordPress installations, not one Multisite trying to represent all of them.

If instead you mean:

I have one agency/platform and want hundreds of microsites, all administered by me

then I'd consider a single Multisite network first. WordPress Multisite is specifically designed to have multiple sites sharing the same WordPress installation/resources. WordPress Developer Resources

For a client-hosting business, my default recommendation is: one Multisite network per client + one server + SpinupWP + Nginx/PHP-FPM + separate DB per network + WP-CLI automation.

If you tell me roughly how many client networks × microsites you expect (e.g. 20 × 10, or 100 × 50) and whether you're using Cloudflare, I can lay out the exact server architecture, directory structure, database strategy, caching, backups, and provisioning workflow I'd use.

If your goal is multiple client microsites, with each client potentially having several sites, all on one host, I’d generally use separate WordPress Multisite installations/networks, rather than putting every client into one giant Multisite network.

WordPress itself supports multiple independent WordPress instances on the same server, including instances with separate databases. WordPress Developer Resources WordPress Developer Resources

My recommended architecture

                         ┌── Client A Network
                         │   ├── a.com
                         │   ├── a-shop.com
                         │   └── a-campaign.com
                         │
Server / VPS ── Nginx ───┼── Client B Network
                         │   ├── b.com
                         │   └── b-campaign.com
                         │
                         ├── Client C Network
                         │   ├── c.com
                         │   └── c-event.com
                         │
                         └── Client D Network
                             └── d.com

Each network gets:

• Its own WordPress installation
• Its own database
• Its own wp-config.php
• Its own Multisite network/admin
• Its own plugin/theme set
• Its own backups
• Its own PHP-FPM pool/container if you want stronger isolation

Then use domain mapping inside each network for the actual client domains. Modern WordPress Multisite has native domain mapping. WordPress Developer Resources

Why I prefer this over one mega-network

A single network is great when all sites are essentially part of the same platform. For example:

company.com
company.com/us
company.com/uk
company.com/fr

But for unrelated clients, I'd avoid:

ONE MULTISITE
├── Client A
├── Client B
├── Client C
├── Client D
├── Client E
└── ...

The reason is blast radius. Multisite shares WordPress core, plugins/themes and a database across the network. WordPress explicitly describes a network as sites sharing the same installation core files, with separate site tables in the database. WordPress Developer Resources WordPress Developer Resources

So if Client A needs a plugin that conflicts with Client B's stack, or a plugin update breaks something, you've potentially created a problem for the entire network.

With separate networks:

/client-a/
    WP + DB
/client-b/
    WP + DB
/client-c/
    WP + DB

you get a much nicer operational boundary.

What I'd actually run

For a serious production setup, I'd use something like:

Nginx → PHP-FPM → WordPress Multisite → MariaDB/MySQL

and organize the filesystem roughly:

/var/www/
    client-a/
        public/
        ...
    client-b/
        public/
        ...
    client-c/
        public/
        ...

Databases:

wp_client_a
wp_client_b
wp_client_c

Or, if you have enough clients, put each network in its own database server/schema depending on your DB architecture. WordPress officially supports multiple instances using separate databases. WordPress Developer Resources

For Nginx, each client's domains can point at that network's document root, with the appropriate Multisite rewrite configuration. WordPress documents Nginx-specific Multisite configurations as well. WordPress Developer Resources

One important distinction

If by "multiple WP multisite networks" you mean something like:

I want 50–500 small client sites, and I want to provision them automatically.

Then I'd go a step further and consider containerizing each network:

                  Load Balancer / Nginx
                         │
        ┌────────────────┼────────────────┐
        ↓                ↓                ↓
   WP Network A     WP Network B     WP Network C
   PHP-FPM           PHP-FPM          PHP-FPM
   MySQL             MySQL            MySQL

That gives you much better isolation and makes cloning/provisioning networks considerably easier.

For a smaller operation, though, one VPS + Nginx + PHP-FPM + separate WP Multisite directories/databases is perfectly reasonable.

Rule of thumb

• Same organization / same plugin stack: one Multisite network.
• Different clients but highly standardized stack: separate networks on the same host.
• Clients require different plugins/themes or you want strong isolation: definitely separate networks.
• Clients are high-value / security-sensitive: separate containers or even separate VPS instances.
• Hundreds/thousands of sites with automated provisioning: consider a containerized platform rather than manually managing WP installs.

If you tell me roughly how many client sites (e.g. 20, 100, 500), whether you use Nginx or Apache, and whether you're on a VPS/Docker/Kubernetes, I can lay out the exact architecture I'd use, including filesystem, databases, PHP-FPM, DNS/SSL, backups, and automated provisioning.

company.com
company.com/us
company.com/uk
company.com/fr

But for unrelated clients, I'd avoid:

ONE MULTISITE
├── Client A
├── Client B
├── Client C
├── Client D
├── Client E
└── ...

The reason is blast radius. Multisite shares WordPress core, plugins/themes and a database across the network. WordPress explicitly describes a network as sites sharing the same installation core files, with separate site tables in the database. WordPress Developer Resources WordPress Developer Resources

So if Client A needs a plugin that conflicts with Client B's stack, or a plugin update breaks something, you've potentially created a problem for the entire network.

With separate networks:

/client-a/
    WP + DB
/client-b/
    WP + DB
/client-c/
    WP + DB

you get a much nicer operational boundary.

What I'd actually run

For a serious production setup, I'd use something like:

Nginx → PHP-FPM → WordPress Multisite → MariaDB/MySQL

and organize the filesystem roughly:

/var/www/
    client-a/
        public/
        ...
    client-b/
        public/
        ...
    client-c/
        public/
        ...

Databases:

wp_client_a
wp_client_b
wp_client_c

Or, if you have enough clients, put each network in its own database server/schema depending on your DB architecture. WordPress officially supports multiple instances using separate databases. WordPress Developer Resources

For Nginx, each client's domains can point at that network's document root, with the appropriate Multisite rewrite configuration. WordPress documents Nginx-specific Multisite configurations as well. WordPress Developer Resources

One important distinction

If by "multiple WP multisite networks" you mean something like:

I want 50–500 small client sites, and I want to provision them automatically.

Then I'd go a step further and consider containerizing each network:

                  Load Balancer / Nginx
                         │
        ┌────────────────┼────────────────┐
        ↓                ↓                ↓
   WP Network A     WP Network B     WP Network C
   PHP-FPM           PHP-FPM          PHP-FPM
   MySQL             MySQL            MySQL

That gives you much better isolation and makes cloning/provisioning networks considerably easier.

For a smaller operation, though, one VPS + Nginx + PHP-FPM + separate WP Multisite directories/databases is perfectly reasonable.

Rule of thumb

• Same organization / same plugin stack: one Multisite network.
• Different clients but highly standardized stack: separate networks on the same host.
• Clients require different plugins/themes or you want strong isolation: definitely separate networks.
• Clients are high-value / security-sensitive: separate containers or even separate VPS instances.
• Hundreds/thousands of sites with automated provisioning: consider a containerized platform rather than manually managing WP installs.

If you tell me roughly how many client sites (e.g. 20, 100, 500), whether you use Nginx or Apache, and whether you're on a VPS/Docker/Kubernetes, I can lay out the exact architecture I'd use, including filesystem, databases, PHP-FPM, DNS/SSL, backups, and automated provisioning.

If you mean multiple separate WordPress Multisite networks, each containing a group of client microsites, I’d avoid trying to cram everything into one giant Multisite installation.

What I’d use

One VPS + Nginx + PHP-FPM + MariaDB/MySQL + separate WordPress Multisite installs, managed with something like RunCloud or Docker.

For example:

VPS
├── Network A — agency clients
│   ├── client1.com
│   ├── client2.com
│   └── client3.com
│
├── Network B — another client group
│   ├── client4.com
│   └── client5.com
│
└── Network C — internal / special-purpose sites
    ├── client6.com
    └── client7.com

This gives you network-level isolation while still getting the efficiency of Multisite. WordPress Multisite shares the WordPress core, themes and plugins within a network, while each site has its own content tables. WordPress Developer Resources WordPress Developer Resources

My preferred stack

• Ubuntu LTS
• Nginx
• PHP 8.3/8.4 + PHP-FPM
• MariaDB or MySQL
• Redis object cache
• WP-CLI
• Cloudflare DNS/CDN
• RunCloud if you want a convenient management layer, or Docker if you're comfortable managing containers.
• Automated off-server backups
• Separate PHP-FPM pool/resources where appropriate

RunCloud, for example, has documented support for running WordPress Multisite in Docker. RunCloud Website

Why I'd use separate networks

Suppose you have 50 microsites.

Putting all 50 into one network means:

ONE WP installation
ONE network
50 sites
ONE plugin/theme ecosystem
ONE network administrator/security boundary

That's great when the sites are genuinely part of the same platform.

But if you have:

Network A = 15 restaurants
Network B = 10 real-estate clients
Network C = 20 small-business clients

I'd make those three separate Multisite networks.

That lets you independently control themes/plugins and network administrators. WordPress's network-level plugin activation is specifically scoped to the network. WordPress Developer Resources

What about multiple networks inside one WordPress installation?

Technically, multiple Multisite networks can share one WordPress installation, and WordPress's own documentation discusses this architecture. But it's a fairly specialized setup and isn't where I'd start for a client-hosting platform. Make WordPress

I'd much rather have:

                 VPS
                  │
        ┌─────────┼─────────┐
        │         │         │
     WP-MS A   WP-MS B   WP-MS C
        │         │         │
      DB-A      DB-B      DB-C

rather than building a complicated "multinetwork" WordPress architecture.

Domain mapping

For client microsites, domain-based Multisite + domain mapping is particularly nice:

Network:
agency-sites.example

Sites:
client-a.com
client-b.com
client-c.com

WordPress has native domain mapping support in current versions, so you don't need the old MU Domain Mapping approach. DNS points the domains at the server, SSL is configured for them, and the site's address can be set to the client's actual domain. WordPress Developer Resources

One important distinction

If by "multiple WP multisite networks" you actually mean:

"I want to host lots of unrelated client WordPress sites cheaply, and I don't necessarily need them to be Multisite."

Then I'd recommend separate WordPress installations, not Multisite.

For client hosting, my hierarchy would be:

WordPress itself describes separate installations with separate databases as the more isolated multi-instance architecture. WordPress Developer Resources

If you're building this as an actual client-microsite hosting platform, I'd probably choose Ubuntu + Nginx + PHP-FPM + MariaDB + Redis + WP-CLI + Cloudflare + RunCloud, with one Multisite install per logical client group.

If you tell me roughly how many microsites (10/50/500), whether clients need their own WP admin, and whether you want automatic provisioning, I can lay out the exact server architecture I'd use, including CPU/RAM sizing, database layout, backups, SSL, wildcard DNS, and deployment/provisioning.

If you mean one physical/virtual host running multiple independent WordPress Multisite networks, I’d avoid trying to make one giant Multisite installation do everything.

What I’d use

Nginx + PHP-FPM + MariaDB/MySQL + WP-CLI, with one WordPress installation per client/network.

For example:

Host
├── nginx
├── PHP-FPM
├── MariaDB
│
├── /srv/wp/client-a/
│   └── WordPress Multisite → 20 microsites
│
├── /srv/wp/client-b/
│   └── WordPress Multisite → 8 microsites
│
├── /srv/wp/client-c/
│   └── WordPress Multisite → 35 microsites
│
└── /srv/wp/client-d/
    └── WordPress Multisite → 12 microsites

Each network gets its own:

• WordPress core/files
• database (or at least its own DB/schema)
• wp-config.php
• plugins/themes
• uploads
• domain mappings
• backups
• PHP-FPM pool/resource limits if needed

That's a much better boundary for client isolation than putting every client's microsites into one enormous network. WordPress itself describes multiple WP instances + multiple databases as a supported architecture, distinct from a single Multisite network. WordPress Developer Resources WordPress Developer Resources

Why I prefer this architecture

A Multisite network intentionally shares WordPress core, plugins and themes across all its sites. WordPress Developer Resources Learn WordPress

That's fantastic when the sites are genuinely part of the same platform:

Client A → 25 franchise sites → same theme/plugin stack

But it's less attractive when you're hosting different clients because:

• A bad plugin update can affect every site in that network.
• A compromised plugin/theme has a larger blast radius.
• Clients may require incompatible plugin versions.
• Network-wide plugin/theme management becomes awkward.
• Database restores become more complicated.
• You can move one client's entire network elsewhere much more easily if it's isolated.
• Resource limits can be applied per client/network.

So I'd make the network itself the client isolation boundary.

The stack I'd build

Nginx has explicit WordPress Multisite configurations, including domain-based multisite, and PHP-FPM is a standard supported approach. WordPress Developer Resources

Domain structure

For client microsites I'd use domain-based Multisite:

client.com
client-brand.com
another-brand.com
store.client.com

rather than:

client.com/site1
client.com/site2

WordPress supports domain-based networks and mapped domains; the DNS/server layer simply needs to route those domains to the appropriate network's WordPress installation. WordPress Developer Resources

You can have Nginx route:

foo.com          → /srv/wp/client-a/
bar.com          → /srv/wp/client-a/
example.org      → /srv/wp/client-b/
whatever.net     → /srv/wp/client-c/

while WordPress determines which site within that network should handle the request.

One important alternative

If the microsites don't actually need Multisite, I'd seriously consider:

one independent WordPress install per microsite.

That's:

client-a-site-1 → WP install
client-a-site-2 → WP install
client-a-site-3 → WP install
client-b-site-1 → WP install

It's more resource-heavy and requires more management, but provides the strongest isolation.

So my rule of thumb would be:

• Same client + same plugin/theme ecosystem: Multisite network.
• Different clients: separate Multisite networks.
• High-value / unusual / security-sensitive client: independent WP install.
• Dozens/hundreds of nearly identical sites: Multisite becomes particularly attractive.

I'd also use WP-CLI + automation rather than manually maintaining these. WP-CLI has native commands for converting and installing Multisite networks. WordPress Developer Resources

If you're talking about something like 5–20 clients, each with 10–100 microsites, I can lay out the exact server architecture I'd use—including Nginx vhosts, PHP-FPM pools, database layout, Redis, backups, deployment, DNS/domain mapping, and how I'd provision a new client network automatically.

For client microsites I'd use domain-based Multisite:

client.com
client-brand.com
another-brand.com
store.client.com

rather than:

client.com/site1
client.com/site2

WordPress supports domain-based networks and mapped domains; the DNS/server layer simply needs to route those domains to the appropriate network's WordPress installation. WordPress Developer Resources

You can have Nginx route:

foo.com          → /srv/wp/client-a/
bar.com          → /srv/wp/client-a/
example.org      → /srv/wp/client-b/
whatever.net     → /srv/wp/client-c/

while WordPress determines which site within that network should handle the request.

One important alternative

If the microsites don't actually need Multisite, I'd seriously consider:

one independent WordPress install per microsite.

That's:

client-a-site-1 → WP install
client-a-site-2 → WP install
client-a-site-3 → WP install
client-b-site-1 → WP install

It's more resource-heavy and requires more management, but provides the strongest isolation.

So my rule of thumb would be:

• Same client + same plugin/theme ecosystem: Multisite network.
• Different clients: separate Multisite networks.
• High-value / unusual / security-sensitive client: independent WP install.
• Dozens/hundreds of nearly identical sites: Multisite becomes particularly attractive.

I'd also use WP-CLI + automation rather than manually maintaining these. WP-CLI has native commands for converting and installing Multisite networks.

If you mean several independent WordPress Multisite networks, each containing a handful of client microsites, I would not try to cram everything into one giant Multisite network.

My preferred architecture is:

One VPS / dedicated host
│
├── Network A
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   └── client-e.com
│
└── Network C
    ├── client-f.com
    └── client-g.com

Each network gets its own WordPress installation + database, while the host provides the shared infrastructure.

WordPress itself distinguishes between a single Multisite network and multiple independent WordPress instances; a Multisite network shares its WordPress core, plugins/themes, and database structure across its sites. WordPress Developer Resources WordPress Developer Resources

What I'd use

Server

Ubuntu/Debian + Nginx + PHP-FPM + MariaDB/MySQL + Redis

For an agency/client setup, I'd run something roughly like:

• Nginx
• PHP 8.3+
• PHP-FPM
• MariaDB 10.11+ or MySQL 8
• Redis object cache
• WP-CLI
• Composer
• Git
• automated off-server backups
• Let's Encrypt
• Cloudflare in front, if appropriate

I'd strongly consider Docker if you're comfortable with it, but it's not mandatory. Containers become particularly attractive when you want each client/network to have slightly different PHP extensions, PHP versions, or infrastructure.

WordPress itself

I'd use Bedrock rather than maintaining raw WordPress installations manually. Bedrock gives you Composer-based dependency management and environment configuration, and it supports Multisite. Roots Roots

So, for example:

/srv/www/
    network-a/
        current/
            web/
            config/
            vendor/

    network-b/
        current/
            web/
            config/
            vendor/

    network-c/
        current/
            web/
            config/
            vendor/

Each gets its own:

database
wp-config/environment
uploads
plugins/themes
deployment pipeline
backup

but they can all use the same host-level Nginx/PHP/Redis infrastructure.

Why I'd separate the networks

This is the important part.

If you put every client into one Multisite network, you gain operational simplicity, but you create a pretty significant blast radius.

For example:

ONE NETWORK
100 client microsites
       │
       ├── one WP core
       ├── shared plugins
       ├── shared themes
       ├── shared network administration
       └── shared database

A bad plugin update or incompatible code can potentially affect everyone.

WordPress also makes plugins/themes fundamentally network-level resources: they're installed once and can be activated per-site or across the network. WordPress Developer Resources

Instead:

NETWORK A
10 related client sites
      │
      └── isolated from NETWORK B

NETWORK B
8 related client sites
      │
      └── isolated from NETWORK C

That gives you a useful middle ground:

one Multisite network per client group/project/platform, rather than one network per client or one enormous network for everybody.

A good rule of thumb

I'd structure it according to how much the sites have in common:

WordPress itself notes that Multisite is particularly useful where sites share resources such as themes/plugins, while strongly interconnected sites aren't necessarily a good fit for Multisite. WordPress Developer Resources

The stack I'd personally build

For an agency running client microsites, something like this is very clean:

                    Cloudflare
                       │
                       ▼
                    Nginx
                       │
            ┌──────────┴──────────┐
            │                     │
        PHP-FPM                 Redis
            │
     ┌──────┼───────┐
     ▼      ▼       ▼
 Network A Network B Network C
     │         │        │
     ▼         ▼        ▼
  MariaDB   MariaDB  MariaDB

You don't necessarily need a separate MariaDB server/database process for every network. You can have one database server with separate databases/users per installation:

mysql
├── network_a
├── network_b
├── network_c
├── client_special_1
└── client_special_2

That's a much nicer isolation boundary than throwing all clients into one database.

Deployment

This is where I'd really lean into automation.

Have each network as a Git/Composer project:

git push
    ↓
CI/CD
    ↓
composer install
    ↓
WP core/plugin updates
    ↓
database migrations
    ↓
cache flush
    ↓
deploy

And use WP-CLI for network management. WP-CLI has native commands for creating/converting Multisite installations, including wp core multisite-install. WordPress Developer Resources WordPress Developer Resources

That makes provisioning a new client network much less painful.

One thing I'd avoid

I wouldn't use a control panel as the architecture itself.

cPanel/Plesk can certainly manage this, but if you're talking about dozens/hundreds of client microsites, I'd rather have:

Nginx + PHP-FPM + MariaDB + Redis + WP-CLI + Composer + Git + automated backups

and optionally Docker.

The control plane should be your deployment/infrastructure automation, not a pile of manually created hosting accounts.

My recommendation

If I were building this today, I'd start with:

Ubuntu 24.04 → Nginx → PHP 8.3/8.4 → MariaDB → Redis → Bedrock → WP-CLI → Cloudflare → automated offsite backups

Then:

one Bedrock installation per independent Multisite network, with each network containing the microsites that genuinely share a stack.

That gives you a very good balance between density, isolation, maintainability, and disaster radius.

If you're expecting something like 50–500 microsites, the architecture changes somewhat—I would introduce a more deliberate provisioning/deployment layer rather than treating each network as a manually maintained WordPress install.

If you mean running several WordPress Multisite networks (each with multiple client microsites) on one physical host, I’d usually avoid putting all clients into one giant Multisite unless the clients are highly standardized. A better setup is often:

• One server/VPS
• Multiple isolated WordPress Multisite installs
• A management layer for deployments, backups, and monitoring

Multisite is powerful, but all subsites in a network share WordPress core, plugins, themes, database resources, and failure domains. A bad plugin or database issue can affect every client in that network. HostWise

A solid agency-style stack

Server layer

For a self-managed setup:

• Ubuntu LTS VPS
• Nginx (or OpenLiteSpeed if you prefer LiteSpeed caching)
• PHP-FPM
• MariaDB/MySQL
• Redis object cache
• Cloudflare DNS/CDN
• Automated backups to S3-compatible storage

Typical sizing:

• Small portfolio (10–30 microsites): 4–8 vCPU, 16–32 GB RAM
• Medium portfolio (30–100+ microsites): 8–16 vCPU, 32–64 GB RAM
• Heavy WooCommerce/membership sites: separate them

WordPress management

Use one of:

• MainWP — good if you want self-hosted control over many separate WordPress installs.
• wp-umbrella.com — agency-focused monitoring, backups, and reporting.
• managewp.com — simpler SaaS management.

Hosting platforms if you don't want to run the server

For agencies, these are common choices:

• cloudways.com — good middle ground: managed cloud server, multiple WordPress apps, more control. CloudPipelines
• kinsta.com — premium managed WordPress, strong isolation and developer tooling. NorthiScale
• wpengine.com — agency-oriented managed WordPress with staging and workflow tools. FindBestWebHosting

How I would structure client microsites

Example:

/srv/www/

network-a/
  WordPress Multisite
  clients:
    client1.com
    client2.com
    client3.com

network-b/
  WordPress Multisite
  clients:
    client4.com
    client5.com

standalone/
  high-value clients
  WooCommerce
  custom plugins

Keep separate networks for groups that share:

• the same theme
• the same plugin stack
• the same update schedule
• the same ownership/control model

Do not put unrelated clients together if:

• they need different plugins
• they require admin access
• they have custom development
• downtime would be costly

My default recommendation for an agency

For most client microsite businesses:

VPS + Docker + separate WordPress Multisite networks + Cloudflare + automated backups + MainWP/WP Umbrella

or, if you want less server work:

Cloudways/Kinsta/WP Engine + separate installs where possible.

A key question: are these microsites all based on the same template/brand system (like franchise locations, schools, local branches), or are they independent client websites? That changes whether Multisite is the right architecture.

If you mean one physical server hosting several independent client “microsite networks,” I’d generally avoid trying to make everything one giant Multisite.

What I’d use

Nginx + PHP-FPM + MariaDB/MySQL + WP-CLI, with one WordPress Multisite installation per client/network.

For example:

server
├── client-a/
│   └── WordPress Multisite
│       ├── a-client.com
│       ├── product-a.com
│       └── campaign-a.com
│
├── client-b/
│   └── WordPress Multisite
│       ├── client-b.com
│       └── microsite-b.com
│
└── client-c/
    └── WordPress Multisite
        ├── client-c.com
        └── microsite-c.com

That gives you network-level isolation while still getting the operational advantages of Multisite within each client's collection of sites.

WordPress itself supports multiple independent WordPress instances on the same server, and Multisite is specifically designed to let several sites share one installation's core, plugins/themes, and database infrastructure. WordPress Developer Resources WordPress Developer Resources

Why I'd structure it this way

If Client A has 10 microsites, put those 10 into one Multisite network. Client B gets a separate network.

That means:

• Shared plugins/themes within a client
• Easy deployment of a common agency theme
• One WP core update per client network
• Separate databases/files between clients
• A client's super-admin doesn't inherently become the administrator of another client's network
• You can customize the stack/plugins per client
• Much easier to move a client away later than if every client lives in one enormous network

The downside is that WordPress Multisite sites within a network are coupled: they share the WordPress installation and plugin/theme code, and the network has its own administration model. WordPress Developer Resources WordPress Developer Resources

Domain mapping

For microsites, I'd use domain-based Multisite + native domain mapping.

For example:

network-client-a.com       ← network/admin domain

microsite1.com             → site 1
microsite2.com             → site 2
microsite3.com             → site 3

WordPress 4.5+ has native domain mapping, so you don't need the old MU Domain Mapping approach. Each domain points at the same server/WordPress installation, and WordPress maps it to the appropriate site. WordPress Developer Resources

If you literally mean multiple networks inside one WordPress install

That's possible too, using the old/hidden multi-network functionality. The WP Multi Network plugin exposes this functionality and allows multiple Multisite networks to coexist around a shared WordPress installation/user system. WordPress.org English (UK)

I'd be more cautious with that architecture, though.

For an agency hosting client microsites, I'd rank the choices:

My preferred production stack

If you're comfortable administering Linux, I'd do:

Ubuntu/Debian
    ↓
Nginx
    ↓
PHP-FPM
    ↓
WordPress Multisite(s)
    ↓
MariaDB/MySQL

Cloudflare
    ↓
DNS + SSL + caching/WAF

WP-CLI
    ↓
updates / deployments / backups / automation

Then give each client network its own:

/var/www/client-a/
    current/
    releases/
    shared/

    database: client_a_wp

/var/www/client-b/
    current/
    releases/
    shared/

    database: client_b_wp

Nginx is well suited to Multisite; WordPress provides specific Nginx configurations for domain/subdirectory Multisite setups. WordPress Developer Resources

One important distinction: if these are truly client-owned sites where clients might eventually need arbitrary plugins, custom code, WooCommerce, etc., I'd lean toward one standalone WordPress installation per client, rather than Multisite. If they're essentially templated microsites that you centrally operate, Multisite becomes much more attractive.

If you tell me roughly how many clients/sites you're talking about (e.g. 20 clients × 5 sites) and whether you're using Docker or a conventional VPS, I can recommend the exact architecture I'd use, including Nginx, PHP-FPM, DB, backups, SSL, and deployment layout.

If you mean several independent WordPress Multisite networks, each containing a bunch of client microsites, I’d avoid trying to cram everything into one giant Multisite.

My preferred setup

One VPS → multiple independent WordPress Multisite installations → Nginx + PHP-FPM + MariaDB → WP-CLI automation.

For example:

VPS
├── /srv/wp/network-a
│   ├── client1.com
│   ├── client2.com
│   └── client3.com
│
├── /srv/wp/network-b
│   ├── client4.com
│   ├── client5.com
│   └── client6.com
│
└── /srv/wp/network-c
    ├── client7.com
    └── client8.com

Each directory is an independent Multisite network, with its own:

• database
• wp-config.php
• plugins/themes
• Network Admin
• upgrades
• backups
• PHP-FPM pool
• client separation

That's a much nicer operational boundary than putting every client into one enormous network.

WordPress itself supports this model, and WP-CLI is particularly useful here: wp site create supports a --network_id, and WP-CLI can manage Multisite networks from scripts/CI. developer.wordpress.org

What I'd use for the host

If you want control and good economics:

Ubuntu/Debian + Nginx + PHP-FPM + MariaDB + Redis + object/page caching + WP-CLI

I'd put Cloudflare in front for DNS/CDN/WAF.

For management, SpinupWP is worth considering. It provisions Nginx/PHP-FPM WordPress servers and explicitly supports creating Multisite installations. It also gives each hosted site its own PHP-FPM pool and filesystem user. spinupwp.com

One caveat: SpinupWP's notion of a "site" and WordPress's notion of a "network" aren't identical, so I'd treat each Multisite network as a separately managed server site.

How I'd architect it

For a small agency:

                    Cloudflare
                        │
                        ▼
                 ┌─────────────┐
                 │    Nginx    │
                 └──────┬──────┘
                        │
          ┌─────────────┼─────────────┐
          ▼             ▼             ▼
       Network A     Network B     Network C
       PHP-FPM       PHP-FPM       PHP-FPM
          │             │             │
       DB A           DB B           DB C

Then automate provisioning with WP-CLI:

wp core multisite-install ...
wp site create --slug=client-a ...
wp site create --slug=client-b ...
wp plugin install ...
wp theme install ...

WP-CLI's core multisite-install can create a fresh Multisite installation, while wp site create handles individual sites. developer.wordpress.orgdeveloper.wordpress.org

When I'd use a single Multisite network instead

If these microsites are essentially one product/platform—same plugins, same theme, same administrators, same deployment lifecycle—then one Multisite network is actually excellent.

For example:

agency-network.com
├── client-a.com
├── client-b.com
├── client-c.com
├── client-d.com
└── client-e.com

That's considerably easier to maintain.

But if Client A should never be able to affect Client B, I'd use separate networks.

The important distinction

There are really three architectures:

For an agency hosting dozens/hundreds of relatively lightweight microsites, I'd probably choose several independent Multisites on a few VPSs, rather than one massive network or one WordPress installation per client.

Also don't underestimate memory: PHP-FPM pools, cron jobs, and traffic from one site can affect others on the same server. SpinupWP recommends roughly 10–20 small brochure sites on a 1 CPU/2 GB server and emphasizes spreading sites across servers as the fleet grows. spinupwp.com

If you tell me roughly how many microsites (e.g. 20/100/500), whether clients need their own WP admins, and whether the sites are mostly brochure sites, I can recommend a concrete stack/server size and directory/database layout.

If you mean “I’m an agency hosting lots of client microsites, and I want several independent WordPress Multisite networks on one VPS/server”, I’d structure it differently from simply putting every client into one giant network.

My preferred setup

One VPS → Nginx → multiple WordPress Multisite installations → each installation is its own network.

For example:

Server
├── Network A
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   ├── client-e.com
│   └── client-f.com
│
└── Network C
    ├── client-g.com
    └── client-h.com

Each network gets its own:

• WordPress codebase
• database
• wp-content
• plugins/themes
• Network Admin
• backups
• PHP-FPM pool/process limits, if you want isolation

WordPress itself supports multiple independent installations on one server, and Multisite gives you the ability to put multiple sites inside each installation. WordPress Developer Resources WordPress Developer Resources

What I'd use

Server: Ubuntu/Debian VPS
Web server: Nginx
PHP: PHP-FPM
Database: MariaDB or MySQL
Management: CloudPanel is a particularly nice choice if you don't want to hand-maintain Nginx vhosts, SSL, databases, PHP versions, etc. It supports WordPress/Multisite and provides Nginx vhost management. CloudPanel CloudPanel
WordPress management: WP-CLI + Git/Composer if you're comfortable with them.

Then I'd have something like:

/var/www/
    network-01/
        public/
        database
    network-02/
        public/
        database
    network-03/
        public/
        database

Each Multisite can then have its own mapped client domains. WordPress has native domain mapping in current Multisite, so a site can live internally as a subsite but present itself as client.com. WordPress Developer Resources

Why I wouldn't put everything in one Multisite

If these are genuinely different clients, I'd generally use separate networks rather than:

ONE giant network
  └── 100 client sites

A single network means the sites share the same WordPress installation, plugins/themes, and database infrastructure. WordPress Developer Resources

That's great when the sites are intentionally part of the same ecosystem—for example:

acme.com
├── location1
├── location2
├── location3
└── location4

But for unrelated clients, separation is valuable. If Client A requires a plugin/version/theme that you don't want Client B touching, separate networks give you a much cleaner boundary.

There is also a “multi-network” option

Technically, WordPress can run multiple Multisite networks from one WordPress installation. The WP Multi Network plugin exposes this functionality. WordPress.org English (UK) Make WordPress

So you could theoretically have:

ONE WordPress installation
        │
        ├── Network A
        │     ├── client1.com
        │     └── client2.com
        │
        ├── Network B
        │     ├── client3.com
        │     └── client4.com
        │
        └── Network C
              └── client5.com

That's interesting for an agency platform, but I wouldn't make it my default architecture for client hosting. It's clever, but it introduces another layer of WordPress complexity and reduces the isolation between networks. The plugin itself describes this as turning one Multisite installation into many networks sharing a global user layer. WordPress.org English (UK)

The sweet spot

For an agency, I'd probably do:

1 VPS
→ CloudPanel/Nginx
→ one WP installation per client group
→ 5–30 microsites per Multisite network

For example:

VPS
│
├── franchise-network
│   └── 25 franchise microsites
│
├── nonprofit-network
│   └── 12 nonprofit microsites
│
├── local-business-network
│   └── 18 business microsites
│
└── premium-client
    └── standalone WordPress

That gives you high site density without making the entire server one giant blast radius.

I'd also put Redis object caching, Nginx FastCGI/page caching where appropriate, automated off-server backups, and Cloudflare in front of the domains. Nginx is officially supported for Multisite, although the rewrite configuration needs to account for Multisite. WordPress Developer Resources

If you tell me roughly how many microsites (10 / 50 / 200 / 1,000), whether clients need WP admin access, and what VPS you're considering, I can recommend a concrete architecture—including CPU/RAM, database layout, DNS, SSL, backups, and how I'd organize the networks.

If you mean multiple client microsites on one server, I would usually not put all clients into one giant WordPress Multisite network unless they are truly related (same organization, same plugins/themes, same admin team). For an agency setup, the better pattern is often:

• One server
• Multiple isolated WordPress installs
• Managed from a central dashboard
• Separate databases, backups, and failure domains

WordPress Multisite is great for franchises, schools, departments, or a product family. It is less ideal when every client is independent because a bad plugin update, database issue, or security problem can affect the whole network. HostWise

My preferred stacks

Option 1: VPS + managed WordPress control panel (best balance)

Good for dozens of small/medium client sites.

Typical stack:

• Ubuntu LTS VPS
• Nginx
• PHP-FPM
• MariaDB/MySQL
• Redis object cache
• Cloudflare CDN/WAF
• Automated backups
• A WordPress management layer

Good choices:

• Cloudways — easier VPS management without doing everything yourself. WP Consults
• WPMU DEV — built around managing many WordPress sites from one place. WPMU DEV

A typical agency box might be:

• 8–16 GB RAM
• 4–8 vCPU
• NVMe storage
• Redis enabled
• Object/page caching
• Separate staging environments

This comfortably handles many brochure-style client sites.

Option 2: Managed WordPress agency hosting (least maintenance)

Best if your time is worth more than server cost.

Look at:

• WP Engine
• Kinsta

These are more expensive but give you staging, backups, security tooling, and WordPress-specific support. HostWise FindBestWebHosting

Option 3: True WordPress Multisite (only when appropriate)

If you really want multiple networks, I would structure it like:

Server
│
├── Network A
│   ├── Client microsite 1
│   ├── Client microsite 2
│
├── Network B
│   ├── Client microsite 3
│   ├── Client microsite 4

Each network gets:

• its own database
• its own wp-content
• its own domain mapping
• its own backups

Avoid one huge network:

One WP install
 ├── client1.com
 ├── client2.com
 ├── client3.com
 ...
 └── client100.com

That becomes painful when clients need different plugins, PHP versions, permissions, or migrations.

Tools I would add

Management

• MainWP for self-hosted control
• ManageWP for a hosted dashboard

Backups

• Off-server backups (S3-compatible storage)
• Daily database backups
• Weekly full snapshots

Security

• Cloudflare DNS/WAF
• Two-factor authentication
• Limited admin accounts
• Automatic vulnerability scanning

My recommendation by client count

For a small agency running client brochure sites, I’d lean toward separate WordPress installs on a managed VPS, not multiple Multisite networks. It gives you most of the operational benefits without tying all clients together. devpanel.com

If you tell me roughly how many microsites (10? 50? 500?), traffic level, and whether clients need their own WP logins, I can suggest a more specific architecture.

If you mean multiple separate WordPress Multisite networks, with each network containing a group of client microsites, I’d avoid trying to put all the networks into one giant Multisite install.

WordPress itself currently treats a normal Multisite installation as one network per WordPress installation. developer.wordpress.org

What I’d use

A VPS + Nginx + PHP-FPM + MariaDB/MySQL, managed with SpinupWP is probably the sweet spot.

SpinupWP

Structure it roughly like:

VPS
├── Network A
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   ├── client-e.com
│   └── client-f.com
│
└── Network C
    ├── client-g.com
    └── client-h.com

Each network is its own WordPress installation/database, while the server is shared.

That's preferable because:

• One client's plugin/theme problem doesn't necessarily affect every network.
• You can update networks independently.
• You can give each network its own PHP version/configuration.
• Backups/restores are much easier to reason about.
• You can migrate an entire client/network to another server later.
• Client microsites can still share a common theme/plugin stack within their network.

SpinupWP specifically supports creating Multisite installations and gives each site its own PHP-FPM pool and filesystem/user isolation. spinupwp.com

For your use case, I'd probably go one level further

If these are agency/client microsites, I'd organize them by client rather than making one network per tiny site:

Server 1
│
├── Agency Network
│   ├── client1-site1
│   ├── client1-site2
│   ├── client1-site3
│   └── ...
│
├── Client 2 Network
│   ├── microsite1
│   └── microsite2
│
└── Client 3 Network
    ├── microsite1
    └── microsite2

The important distinction is that Multisite is excellent when the sites genuinely share infrastructure—themes, plugins, administration, deployment practices, etc. WordPress explicitly recommends thinking about whether you actually need a network before choosing Multisite. developer.wordpress.org

If the microsites are basically clones of the same marketing site, that's a particularly good fit.

One thing I would not do

I wouldn't build some elaborate multi-network WordPress hack unless you have a very specific reason.

There are ways to run multiple networks around WordPress's multisite architecture, but it's substantially more complicated than simply running several independent WP installations. The core documentation itself describes multiple WordPress instances as a separate architecture from a Multisite network. developer.wordpress.org

My preferred stack

For ~10–50 relatively light client microsites:

Ubuntu/Debian VPS
→ Nginx
→ PHP-FPM
→ MariaDB
→ Redis
→ SpinupWP
→ WordPress Multisite
→ Cloudflare DNS/CDN

I'd enable full-page caching for the mostly-static microsites. SpinupWP's own guidance emphasizes how dramatically page caching changes the number of sites a server can handle; it suggests roughly 10–20 small brochure sites on a 1 CPU/2 GB server as a conservative starting point. spinupwp.com

If you tell me roughly how many microsites you expect (10, 50, 100+), whether each client needs their own network, and whether they're mostly brochure sites or WooCommerce, I can suggest a concrete server architecture and sizing.

If you mean multiple independent WordPress Multisite networks, each containing a bunch of client microsites, I’d generally not put everything into one giant Multisite network.

A good architecture is:

One host
├── Network A (client group / product family)
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   └── client-e.com
│
└── Network C
    ├── client-f.com
    └── client-g.com

WordPress supports multiple networks at the PHP/database level, and WP_Network specifically supports multi-network installations. developer.wordpress.org

What I'd use

For the host:

• Nginx or Caddy in front
• PHP-FPM
• MariaDB/MySQL
• Redis for object caching
• WP-CLI for provisioning/updating
• Let's Encrypt for SSL
• Cloudflare for DNS/CDN/WAF if appropriate
• Separate filesystem/database credentials per network
• Automated off-host backups

Then I'd run one WordPress codebase per network, rather than one codebase for the entire server.

For example:

/srv/wp/
    network-1/
        public/
        wp-content/
    network-2/
        public/
        wp-content/
    network-3/
        public/
        wp-content/

Each network gets its own database (or at least its own database/schema), giving you a much cleaner failure and client-isolation boundary.

Why multiple networks?

Multisite already gives every subsite its own content tables while sharing WordPress core, themes and plugins. developer.wordpress.org

But everything inside a network is coupled:

• same WordPress/plugin versions
• shared network plugins/themes
• super-admin access
• shared database infrastructure
• a bad network-wide plugin update can affect every client

WordPress explicitly notes that plugins can be network-activated and then become active across all sites. developer.wordpress.org

So I'd make the network itself the isolation boundary.

For example, if you have:

• 30 clients using your standard marketing stack → one network
• 5 clients needing WooCommerce → another network
• 10 clients with a completely different plugin/theme stack → another network

That gives you a nice balance between operational efficiency and isolation.

Domain mapping

You don't need a domain-mapping plugin just to do the basic thing anymore. Modern WordPress Multisite has native domain mapping: a subsite can be presented as client.com rather than client.network.com. developer.wordpress.org

So the client-facing structure can simply be:

client1.com
client2.com
client3.com

while internally they're subsites of:

network1.internal-domain.example

You'll need DNS pointing the client domains at your host and SSL certificates for them. developer.wordpress.org

One thing I'd avoid

I wouldn't use a hosting panel's "add 100 WordPress sites" model if your goal is specifically managed client microsites. You end up maintaining dozens of independent WordPress installations.

I'd also avoid putting all clients into a single Multisite network unless they're genuinely homogeneous.

My preferred stack would be:

Nginx/Caddy → PHP-FPM → WordPress Multisite networks → MariaDB → Redis → Cloudflare

with one Multisite installation/network per logical client group.

If you're expecting something like 50–500 microsites on one VPS/bare-metal host, I can also lay out the exact filesystem + Nginx + PHP-FPM + MariaDB + WP-CLI architecture I'd use, including how I'd provision a new client automatically.

If you mean multiple separate WordPress Multisite networks, with each network containing a handful of client microsites, I’d avoid trying to cram everything into one giant Multisite installation.

My preferred setup

One VPS/server → Docker Compose → one WordPress Multisite stack per client/group of clients

For example:

Server
├── Traefik / Nginx Proxy Manager
├── Network A
│   ├── WordPress
│   ├── MariaDB
│   └── Redis
├── Network B
│   ├── WordPress
│   ├── MariaDB
│   └── Redis
└── Network C
    ├── WordPress
    ├── MariaDB
    └── Redis

Each Multisite network can then have:

client-network.com
├── client-network.com
├── microsite1.com
├── microsite2.com
└── microsite3.com

WordPress Multisite is specifically designed for multiple sites sharing the same core, plugins/themes, and database infrastructure, while individual sites retain separate tables. developer.wordpress.org

Why I'd structure it this way

Don't use one enormous network unless all the clients are tightly coupled.

Separate networks give you much better boundaries:

• Updates: You can update Network A without necessarily affecting Network B.
• Plugins: Different clients/networks can have different plugin sets.
• PHP versions: Easier to move a network to a newer PHP version.
• Backups: Restore an entire client's network independently.
• Security: A compromised site still represents a serious problem, but the blast radius is smaller than one huge network.
• Client ownership: Much easier to eventually hand a network/server/container off to a client.
• Performance: Redis/object caching and PHP workers can be tuned per stack.
• Automation: WP-CLI makes provisioning and maintenance highly scriptable. wordpress.org

The stack I'd use

For a modern self-managed host:

Ubuntu/Debian + Docker + Caddy/Traefik + PHP-FPM + MariaDB + Redis + WP-CLI

I'd probably use Caddy or Traefik as the reverse proxy because you're going to have lots of domains and TLS certificates.

Something like:

Internet
   │
   ▼
Caddy / Traefik
   │
   ├── site-a.com ──► WP Multisite A
   ├── site-b.com ──► WP Multisite A
   ├── site-c.com ──► WP Multisite B
   └── site-d.com ──► WP Multisite B

WordPress supports mapping individual multisite subsites to completely separate top-level domains natively; domain mapping has been built into WordPress since 4.5. developer.wordpress.org

One important distinction

If by "multiple networks" you actually mean:

"I have 30 client microsites and want them all on one host, but I don't particularly need separate Multisite networks."

Then I'd probably do one Multisite network, not multiple.

For example:

Agency Network
├── client1.com
├── client2.com
├── client3.com
...
└── client30.com

That is extremely efficient when the sites share a common theme/plugin stack. WP-CLI can create and manage the individual sites, including specifying a network ID when multiple networks exist. developer.wordpress.org

When I'd choose each

For an agency hosting client microsites, my sweet spot would be separate Dockerized Multisite networks, with perhaps 5–20 closely related microsites per network. Then automate provisioning with WP-CLI.

If you tell me roughly how many microsites, how many clients, expected traffic, and whether you're using a VPS/cloud host or something like cPanel, I can suggest the actual architecture (Docker layout, Nginx/Caddy, MariaDB, Redis, backups, DNS, and resource sizing).

If you mean multiple client microsites where each client is a separate site/network on one server, I would usually not put all clients into one giant WordPress Multisite network. The right architecture depends on how much isolation and automation you need.

For an agency setup, these are the common choices:

Option 1 (my usual recommendation): Multiple separate WordPress installs on one VPS

Best for client work.

Stack:

• Ubuntu LTS
• Nginx
• PHP-FPM (separate pool per site if possible)
• MariaDB/MySQL
• Redis object cache
• Cloudflare CDN/WAF
• Let's Encrypt SSL
• Automated backups
• A management layer like Cloudways, RunCloud, or SpinupWP

Pros:

• Client A cannot break Client B as easily
• Easier to hand off a site later
• Plugins/themes can differ
• Easier security boundaries
• Easier staging and migrations

Cons:

• More updates
• More databases
• More installs to manage

This is the model I would choose for most freelance/agency hosting.

Option 2: One WordPress Multisite network per client group

Example:

server
 ├── network1.com
 │    ├── client1.network1.com
 │    ├── client2.network1.com
 │
 ├── network2.com
 │    ├── client3.network2.com
 │    ├── client4.network2.com

Good when:

• Clients are similar businesses
• You reuse the same theme/plugin stack
• You control all sites
• You want rapid cloning

Bad when:

• Clients need different plugins
• Clients need admin freedom
• One compromised plugin could affect many sites

Multisite is excellent for franchises, schools, departments, membership portals, etc., but less ideal as a generic client hosting model. www.host-wise.net

Option 3: Managed WordPress agency hosting

If you don't want to manage Linux:

• Kinsta — premium WordPress-focused, good tooling for agencies
• WP Engine — strong staging/workflow features
• Pressable — agency-oriented WordPress hosting

These cost more, but reduce server maintenance. wpemaillog.com

A solid self-managed setup for ~20–100 microsites

Something like:

Server

• 8 vCPU
• 16–32 GB RAM
• NVMe storage

Software

• Nginx
• PHP 8.3+
• PHP-FPM pools
• MariaDB
• Redis
• WP-CLI
• Fail2ban
• UFW firewall
• Cloudflare

Management

• RunCloud / SpinupWP
• MainWP or similar for updates
• Offsite backups (S3/B2)

If I were building this for an agency today

I would do:

Cloud VPS
    |
    +-- Nginx
    |
    +-- Site 001 (WP install)
    |
    +-- Site 002 (WP install)
    |
    +-- Site 003 (WP install)
    |
    +-- Shared Redis + MariaDB

Then create a separate Multisite network only for repeatable microsite products, such as:

• "every dentist gets the same site template"
• "every franchise location gets a site"
• "every real estate agent gets a branded site"

For normal custom client sites: separate installs win.

If you tell me roughly how many microsites (10, 50, 500?), whether clients need their own WP admin, and whether they are identical templates or custom sites, I can suggest a more exact architecture.

If you're hosting client microsites on one server, I'd generally avoid putting everything into one giant WordPress Multisite network. I'd use multiple independent Multisite installations on the same host, with each network representing a client/project group.

My preferred architecture

Single VPS / bare-metal host
│
├── Nginx
│
├── PHP-FPM
│
├── MariaDB/Postgres
│
├── client-a/
│   └── Bedrock + WordPress Multisite
│       ├── client-a.com
│       ├── microsite1.client-a.com
│       └── microsite2.client-a.com
│
├── client-b/
│   └── Bedrock + WordPress Multisite
│       ├── client-b.com
│       └── campaign.client-b.com
│
└── client-c/
    └── Bedrock + WordPress Multisite
        ├── client-c.com
        └── promo.client-c.com

WordPress officially supports running multiple independent WordPress instances, and Multisite itself is designed to let several sites share one installation/database. developer.wordpress.org

For the server/application layer, I'd use:

• Ubuntu/Debian
• Nginx
• PHP-FPM
• MariaDB
• Redis for object caching
• WP-CLI
• Bedrock for dependency/config management
• Trellis if you want infrastructure/deployment automation

Roots' current Trellis documentation specifically supports managing multiple WordPress sites on a single server, including a shared Trellis instance managing multiple Bedrock sites. roots.io

Why I'd do separate networks

The big advantage is blast-radius control.

If Client A's network has:

WooCommerce
Plugin X
Custom MU plugins
Custom theme

and Client B has:

Plugin Y
Different theme
Different PHP requirements

you don't have to force them into the same WordPress environment.

A conventional Multisite network shares WordPress core, plugins and themes across its sites. developer.wordpress.org

So I'd define the boundary roughly as:

One client/environment = one Multisite network.

Then put that client's microsites inside it.

What about WP Multi Network?

There is actually a WordPress plugin called WP Multi Network that exposes WordPress's underlying ability to have multiple networks in one installation. It can create networks, move subsites between networks, and group sites by domain/path. wordpress.com

I wouldn't make that my default architecture for a client hosting business, though.

It's attractive because you get:

one WP codebase
one global user system
        │
        ├── Network A
        │    ├── Site 1
        │    └── Site 2
        │
        ├── Network B
        │    ├── Site 3
        │    └── Site 4
        │
        └── Network C
             └── Site 5

But you're increasing the complexity of something that WordPress itself treats as an advanced/less-common configuration.

If these are very small microsites

There's an even simpler option:

One Multisite network for all of them.

For example:

microsites.example-host.com
│
├── client1.com
├── client2.com
├── client3.com
├── client4.com
└── client5.com

I'd choose this if:

• all clients use essentially the same stack
• you control the themes/plugins
• sites are mostly brochure/marketing sites
• clients don't need arbitrary plugins
• you want extremely easy provisioning
• you're comfortable with one network-wide failure/update domain

WordPress specifically calls out Multisite as useful when you have sites that are similar but need separate content. learn.wordpress.org

My choice for an agency

For something I'd expect to grow:

Nginx + PHP-FPM + MariaDB + Redis + Bedrock/Trellis

with:

one independent Bedrock/Multisite project per client, all sharing the same physical host.

That gives you a nice middle ground:

The nice thing is that separate networks don't mean separate servers. You can still get excellent host utilization while keeping the WordPress/application boundaries clean.

If you tell me roughly how many clients/sites you're expecting (e.g. 20, 100, 500) and whether the microsites are all based on the same theme/plugin stack, I can recommend a concrete server architecture—including Nginx layout, PHP-FPM pools, database strategy, backups, and deployment model.

If by “multiple WP multisite networks” you mean several independent Multisite networks, each containing a group of client microsites, I’d avoid trying to cram everything into one giant Multisite.

What I’d use

One server → multiple isolated WordPress Multisite installations → each network gets its own DB → client microsites are subsites within that network.

For example:

Server
├── Network A
│   ├── client-a.com
│   ├── client-b.com
│   └── client-c.com
│
├── Network B
│   ├── client-d.com
│   ├── client-e.com
│   └── client-f.com
│
└── Network C
    ├── client-g.com
    └── client-h.com

WordPress officially supports Multisite as one WP installation containing multiple sites, with each site's content in separate tables. developer.wordpress.org

For your use case, I'd build the host roughly like this:

Why multiple networks instead of one?

The big advantage is blast-radius control.

A Multisite network shares WordPress core, plugins/themes, and the user system across its sites. developer.wordpress.org

So I'd group clients that genuinely belong together:

agency-network
    ├── client1
    ├── client2
    └── client3

franchise-network
    ├── location1
    ├── location2
    └── location3

internal-network
    ├── microsite1
    └── microsite2

Then a problematic plugin update on agency-network doesn't necessarily affect the franchise network.

There's another important reason: Multisite doesn't really provide strong tenant isolation. A Super Admin controls the whole network, and network-level plugins/themes can affect every site. WordPress itself notes that Multisite is best suited where sites share resources. developer.wordpress.org

The stack I'd personally choose

If you're comfortable managing Linux:

Nginx + PHP-FPM + MariaDB + WP-CLI + Composer + Cloudflare

Then give every network its own:

/var/www/network-a/
    current/
    shared/
        .env
        uploads/

/var/www/network-b/
    current/
    shared/
        .env
        uploads/

and its own database:

wp_network_a
wp_network_b
wp_network_c

That gives you a nice middle ground between:

one WP install per client
→ lots of duplication/maintenance

and

one enormous Multisite
→ enormous blast radius.

WP-CLI has native commands for creating/managing Multisite installations, which makes provisioning networks scriptable. developer.wordpress.org

For the client domains

You can have a network whose internal sites are:

client1.network.example
client2.network.example

while visitors actually see:

client1.com
client2.com

Modern WordPress Multisite has native domain mapping, so you don't need the old domain-mapping plugin approach. developer.wordpress.org

DNS can simply point the client domains at the server/load balancer, while Nginx routes them to the appropriate Multisite installation.

One thing I'd seriously consider: containers

If this is going to become a real hosting platform for dozens/hundreds of client microsites, I'd go one step further:

                 Cloudflare
                     │
                  Nginx
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
   Network A     Network B     Network C
   container     container     container
        │            │            │
      DB A         DB B         DB C

Docker/Compose makes it much easier to:

• pin PHP versions
• isolate networks
• roll back deployments
• move a network to another server
• give a client/network more CPU/RAM
• upgrade networks independently
• avoid one site's filesystem contaminating another

My default choice would be Docker + Nginx/Traefik + PHP-FPM + MariaDB, with one Compose stack per Multisite network.

If you're talking about 5–50 client microsites, that's probably the sweet spot.

If you're talking 500+ microsites, I'd architect it differently—particularly around database layout, object caching, media storage, provisioning, and load balancing.

If you tell me roughly how many networks, microsites per network, and whether clients get WP admin access, I can recommend the exact architecture (including Nginx/Traefik, Docker layout, DB strategy, Redis, backups, and deployment workflow).

If you mean multiple client microsite groups, where each group is its own WordPress Multisite network, all running on one server, I’d avoid trying to make one giant Multisite do everything.

My preferred architecture

One VPS → Nginx → PHP-FPM → several independent WordPress Multisite installs → MariaDB

For example:

VPS
├── Nginx
├── PHP-FPM
├── MariaDB
├── Redis
│
├── /wp/client-a/       → Multisite network A
│   ├── client-a.com
│   ├── microsite1.com
│   └── microsite2.com
│
├── /wp/client-b/       → Multisite network B
│   ├── client-b.com
│   ├── microsite3.com
│   └── microsite4.com
│
└── /wp/client-c/       → Multisite network C
    ├── client-c.com
    └── microsite5.com

WordPress explicitly supports running multiple independent WordPress instances on the same server, and each Multisite network can contain multiple sites. developer.wordpress.org

Why I'd do it this way

For client work, isolation is more valuable than squeezing everything into one installation.

With separate networks:

• A client's network can have its own plugins/themes.
• You can update one client's WordPress without necessarily affecting everybody.
• A problematic plugin doesn't automatically become a network-wide problem for unrelated clients.
• Backups/restores are much easier to reason about.
• You can eventually migrate one client/network to another server.
• Each client's super-admin boundary is clean.

A normal Multisite network shares WordPress core, plugins and themes across its sites, while site content has separate database tables. developer.wordpress.org

What I'd run on the host

I'd use:

These are in line with current WordPress recommendations; WordPress currently recommends PHP 8.3+, MariaDB 10.11+ or MySQL 8.0+, HTTPS, and Nginx or Apache. wordpress.org Nginx also has documented Multisite configurations. developer.wordpress.org

One thing I would not automatically use

There's a plugin called WP Multi Network that exposes WordPress's ability to have multiple networks inside one Multisite installation. en-gb.wordpress.org

That's interesting if your goal is:

one WordPress codebase → many networks → many sites

But for a client-hosting platform, I'd generally choose:

one WordPress installation/network per client group

rather than building your entire infrastructure around a relatively specialized multinetwork architecture.

The tradeoff is a little more disk space and management overhead, but dramatically better operational boundaries.

If you're talking about 50–500+ microsites

Then I'd make the architecture more deliberate:

Nginx + PHP-FPM pools + MariaDB + Redis + WP-CLI + automated provisioning/backups, with each client getting their own Multisite installation.

You can automate creation of networks/sites with WP-CLI; WordPress provides wp core install-network for converting an installation to Multisite. developer.wordpress.org

If you tell me roughly how many client networks/sites you're expecting (e.g. 10, 50, 200) and your VPS specs, I can recommend the exact architecture, database layout, PHP-FPM setup, and provisioning approach.

If you're talking about one VPS/server hosting several client-specific WordPress Multisite networks, I’d avoid trying to make them all one giant Multisite installation.

My preferred setup

One server → Nginx → PHP-FPM → one independent WordPress/Multisite installation per client/network

For example:

VPS
├── Nginx
├── PHP-FPM
├── MySQL/MariaDB
│
├── client-a/
│   └── WordPress Multisite
│       ├── client-a.com
│       ├── microsite-1.com
│       └── microsite-2.com
│
├── client-b/
│   └── WordPress Multisite
│       ├── client-b.com
│       └── microsite-3.com
│
└── client-c/
    └── WordPress Multisite
        ├── client-c.com
        └── microsite-4.com

That gives you isolation between clients while still letting each client have the convenience of Multisite.

WordPress itself supports multiple independent WordPress instances on the same server, and a Multisite network is essentially one WP installation containing multiple sites that share core files, plugins/themes, and a database structure. developer.wordpress.org

What I'd use

Nginx + PHP-FPM + MariaDB + WP-CLI + Bedrock/Trellis

In particular, I'd seriously consider Roots Trellis + Roots Bedrock.

Trellis is specifically designed to manage multiple WordPress sites on one server, including configuring Nginx, databases, directories, PHP, etc. It can manage multiple sites from a single Trellis configuration. roots.io

So you could have:

                    ┌── client-a.com
Internet → Nginx ──┼── client-b.com
                    ├── client-c.com
                    └── client-d.com

                         ↓
                    PHP-FPM

                         ↓

                  MariaDB/MySQL

with each client's Multisite being independently deployable.

Why I prefer this over one giant network

If Client A's network gets compromised, has a bad plugin, needs a PHP version change, or eventually wants to move to another server, you don't want that to automatically become every client's problem.

Separate networks give you:

• Client isolation
• Separate databases
• Separate wp-config.php
• Independent plugin/theme sets
• Independent PHP/runtime requirements
• Easier backups/restores
• Easier migration to another host
• Easier client-specific staging
• Ability to kill/move one client without touching everyone else

Within each client's network, you still get the benefits of Multisite: shared WordPress core/plugins/themes and separate site tables. developer.wordpress.orgroots.io

One important distinction

If by "multiple WP multisite networks" you mean something like:

20 clients × 5–20 microsites each

then yes, I'd use separate Multisite installations per client.

If you mean:

100 completely unrelated microsites, each belonging to different clients

then I would not necessarily use Multisite at all. I'd probably run independent WordPress installations unless there is a strong operational reason to share plugins/themes/users.

WordPress itself cautions that Multisite is most useful when sites have meaningful shared resources; otherwise separate installations can be more appropriate. developer.wordpress.org

A solid production stack

I'd probably build it as:

Nginx has documented Multisite configurations, including domain-based networks. developer.wordpress.org

For domain-mapped microsites, you'd have something like:

client-a.com          → client A network/site 1
campaign-client-a.com → client A network/site 2
product-client-a.com  → client A network/site 3

WordPress supports domain-based Multisite and mapping separate domains to sites in the network. developer.wordpress.org

If you tell me roughly how many clients/sites you're expecting (e.g. 10 clients × 10 microsites, or 100 × 5), and whether you control the VPS/root access, I can recommend the exact architecture—including Nginx, PHP-FPM pools, database layout, DNS, backups, and deployment strategy.

If you mean one VPS/host running several independent client microsite networks, I’d avoid trying to put every client into one giant Multisite network.

My preferred architecture

One server → several isolated WordPress Multisite installations

For example:

VPS
├── client-a/
│   ├── WordPress Multisite
│   └── sites: a.com, microsite1.com, microsite2.com
│
├── client-b/
│   ├── WordPress Multisite
│   └── sites: b.com, campaign1.com, campaign2.com
│
└── client-c/
    ├── WordPress Multisite
    └── sites: c.com, microsite1.com

Each network gets:

• its own WordPress codebase
• its own database + DB user
• its own uploads
• its own PHP-FPM pool/user if you're serious about client isolation
• Nginx server blocks for the domains
• independent plugin/theme versions

WordPress itself describes Multisite as multiple sites sharing one installation, database, plugins and themes, which is exactly why I wouldn't put unrelated clients into the same network. developer.wordpress.org

Stack I'd use

Nginx + PHP-FPM + MariaDB/MySQL + WP-CLI + Let's Encrypt

Something like:

                         ┌── client-a network
Internet → Nginx → PHP-FPM├── client-b network
                         ├── client-c network
                         └── client-d network

          MariaDB
          ├── db_client_a
          ├── db_client_b
          ├── db_client_c
          └── db_client_d

Nginx has official Multisite configuration guidance, including domain-based Multisite setups. developer.wordpress.org

Why not one huge Multisite?

You can do:

one WP install
    └── 100 client sites

and map each site to its own domain. Domain mapping is built into WordPress, so you don't need the old domain-mapping plugin approach. developer.wordpress.org

But there's a major operational downside:

all those clients become one security/update blast radius.

If a plugin needs a particular version for Client A but Client B needs another version, you're stuck because the network shares installed plugins/themes. WordPress explicitly notes that plugins and themes are installed at the network level. developer.wordpress.org

For an agency hosting unrelated clients, I'd therefore use:

One Multisite network per client/project group, not one Multisite network for the entire server.

An even better variation

If the microsites are really small and all use exactly the same stack, you could have:

Server
│
├── Network A — client/company
│   ├── site1.com
│   ├── site2.com
│   └── site3.com
│
├── Network B — another client/company
│   ├── site4.com
│   └── site5.com
│
└── Network C — another client/company
    └── site6.com

That gives you the efficiency benefits of Multisite while maintaining a useful boundary between clients.

For the server itself, I'd also give each network a separate Unix user/PHP-FPM pool where practical. That's stronger isolation than simply putting multiple WordPress directories under the same www-data account. www.dchost.com

If you tell me roughly how many networks/sites you're talking about (e.g. 5 networks × 20 sites each), and whether you're using a VPS, dedicated server, or Docker, I can recommend the exact architecture and directory/Nginx/PHP-FPM layout.

If you mean several independent WordPress Multisite networks, with each network hosting a bunch of client microsites, I’d avoid putting everything into one giant Multisite network.

My preferred setup is:

One VPS/host → multiple isolated WordPress Multisite installations → Nginx → PHP-FPM → MariaDB/MySQL → Redis

For example:

VPS
├── Nginx
│
├── /srv/wp/network-a/
│   ├── WordPress Multisite
│   └── DB: wp_network_a
│
├── /srv/wp/network-b/
│   ├── WordPress Multisite
│   └── DB: wp_network_b
│
├── /srv/wp/network-c/
│   ├── WordPress Multisite
│   └── DB: wp_network_c
│
└── shared infrastructure
    ├── PHP-FPM
    ├── MariaDB
    ├── Redis
    └── backups

Why I'd do it this way

Each network becomes an isolation boundary.

So you could have:

• network-a → 30 microsites for one agency/client group
• network-b → 20 microsites for another group
• network-c → your own marketing microsites

Within a network, the sites share WordPress core, plugins, themes and the database infrastructure. WordPress/ WP-CLI supports creating and managing sites within a network, including specifying a network_id. developer.wordpress.org

But separate networks mean you can independently:

• update WordPress/plugins
• install different plugins
• have different MU plugins
• give different people Super Admin access
• migrate an entire network
• restore one network from backup
• take down/problem-isolate one client's network
• eventually move a network to another server

That's a much nicer operational boundary than putting 100+ unrelated client sites into one network.

I'd use these pieces

Nginx has specific Multisite configurations documented by WordPress, including handling the rewrite behavior required by Multisite. developer.wordpress.org

The important part: domain mapping

For client microsites, I'd generally use domain-based Multisite and map the clients' actual domains onto the sites.

For example:

Network:
agency-sites.example

Sites:
client-a.com
client-b.com
client-c.com
client-d.com

WordPress 4.5+ has native domain mapping, so you don't need the old MU Domain Mapping plugin. developer.wordpress.org

DNS points the domains at your server/load balancer, Nginx routes them to the appropriate WordPress installation, and WordPress determines which subsite they belong to.

One thing I'd strongly recommend

Don't make one WordPress installation with dozens of separate databases/configurations unless you have a specific reason.

Instead:

                    Nginx
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
       Network A   Network B   Network C
       Multisite   Multisite   Multisite
          │           │           │
       DB-A        DB-B        DB-C

That gives you a very good compromise between resource efficiency and tenant isolation.

And use WP-CLI heavily. It can create/manage sites, network-activate plugins, perform database operations, and automate deployments. developer.wordpress.orgwordpress.org

When I'd use something different

If these are high-value clients who need strong isolation, I'd go one step further:

VPS
├── reverse proxy
├── WP Network A container
├── WP Network B container
├── WP Network C container
└── shared DB/Redis/storage where appropriate

Or even one container/VM per network.

If they're cheap/simple brochure microsites, I'd happily run several networks directly on the same VPS with Nginx/PHP-FPM.

If you're talking about 50–500+ client microsites, I can also lay out the exact architecture I'd use—including Nginx, PHP-FPM pools, Redis, database layout, DNS/SSL, backups, and how I'd automate creating a new client network/site.

If you mean running multiple client microsite networks from one server, I would usually avoid putting all clients into one giant WordPress Multisite unless the sites are truly the same product/template. For an agency setup, the best architecture is often:

Option 1 (usually best): Separate WordPress installs on one managed VPS

Stack:

• Linux VPS (Hetzner, DigitalOcean, Vultr, AWS Lightsail, etc.)
• Nginx + PHP-FPM
• MariaDB/MySQL
• Redis object cache
• Cloudflare CDN/WAF
• Automated backups
• A management layer like SpinupWP, RunCloud, or GridPane

Why:

• Each client gets their own database/files.
• Easier to hand off a site later.
• One bad plugin update does not break every client.
• Cleaner billing and support boundaries.

This is the pattern many agencies settle on when managing mixed client sites. g7cloud.com

Option 2: WordPress Multisite networks (good for templated microsites)

Use this when:

• Every client site shares the same theme.
• You control all plugins/themes.
• Clients do not need deep admin freedom.
• Sites are basically variations of the same product.

Examples:

• Franchise locations
• Real estate agent sites
• School/location microsites
• Dealer networks

A typical setup:

Server
 └── WordPress Multisite Network A
       ├── client1.com
       ├── client2.com
       └── client3.com

 └── WordPress Multisite Network B
       ├── campaign1.com
       ├── campaign2.com
       └── campaign3.com

Avoid putting unrelated clients together because:

• Plugin conflicts affect everyone.
• Database grows together.
• Moving one client away is harder.
• A compromised admin/plugin can impact the entire network. g7cloud.com

Option 3: Managed WordPress hosting for less server work

If you do not want to maintain Linux:

• Kinsta — premium WordPress-focused hosting, strong for agencies and multisite workloads. northiscale.com
• WP Engine — agency workflows, staging, WordPress tooling. northiscale.com
• Cloudways — good middle ground if you want cloud servers without managing everything yourself. cloudpipelines.com

My preferred agency setup

For 10–100 client microsites, I would do:

Cloud VPS
│
├── GridPane/SpinupWP/RunCloud
│
├── Client Site A
│    ├── WP install
│    ├── DB
│    └── staging
│
├── Client Site B
│    ├── WP install
│    ├── DB
│    └── staging
│
└── One or more Multisite networks
     └── only for highly standardized microsites

Server sizing starting point:

• Small portfolio: 4 CPU / 8 GB RAM / NVMe
• Growing agency: 8 CPU / 16 GB RAM
• Lots of traffic: separate servers by client tier

Add:

• Cloudflare DNS + SSL
• nightly off-server backups
• Git/versioned themes
• staging before updates
• uptime monitoring

A key question: are these client microsites all based on the same template/product, or are they independent client websites? That changes whether I’d recommend Multisite or separate installs.