ChatGPT answers, unedited

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.