Most multi-cloud outages that get blamed on a mysterious provider fault turn out, on inspection, to be a documented limit reached at an inconvenient hour. A route table filled up during a deployment. A gateway ran out of throughput headroom during a backup window. A NAT device hit a connection ceiling while a batch job opened thousands of short lived sessions at once. None of these limits were secret. They were simply never part of the design.
Single cloud teams learn their own provider limits the hard way and then remember them. Multi-cloud teams have a harder problem. Each cloud counts differently, raises limits on a different timetable, and fails in a different way when a ceiling is reached. A design that is comfortably inside the limits in one cloud can be one deployment away from the ceiling in another.
Treating quotas as architecture, rather than as trivia to look up during an incident, changes when the problem is found. It moves the discovery from 2 AM to a planning review.
Limits come in four kinds, and they fail differently
A useful inventory separates limits by how they behave, because the response to each kind is different:
- Count limits. Routes per route table, rules per security group or firewall policy, peerings per network, attachments per transit hub, targets per load balancer. These fail discretely. The deployment that adds the next route or rule is rejected, or worse, succeeds in one cloud and fails in the next, leaving the estate in a split state.
- Throughput limits. Gateway bandwidth, tunnel throughput, interconnect capacity, load balancer capacity units. These rarely fail with an error. Traffic slows, queues build, latency rises, and the symptom looks like an application problem long before anyone graphs the gateway.
- Rate limits. API calls to create or modify network resources, DNS queries per second, connection setup rates, storage request rates on a data path. Automation hits these first. A provisioning run that worked for ten networks can throttle itself on the fiftieth, leaving half built infrastructure behind.
- State limits. Concurrent connections through NAT or firewall devices, sessions per appliance, flows per connection tracking table. These depend on behaviour, not configuration size. A chatty service, a retry storm, or a port scan from a compromised workload can consume state that the design assumed would be shared calmly.
Writing down which kind each critical limit is prevents the common mistake of monitoring only the easy counts while the throughput and state ceilings do the actual damage.
Build a limit inventory per cloud, not a global guess
For each cloud in the estate, list the network resources the design depends on, the relevant limit for each, the current usage, and whether the limit can be raised, and if so, how long a raise actually takes. Four fields matter most:
- Current headroom, as a percentage, not an absolute number. Eighty routes free sounds ample until the deployment model adds twenty routes per new tenant, at which point it is four tenants of headroom.
- Growth rate. How fast usage has grown over the last quarter predicts the exhaustion date better than any capacity meeting. Plot it. A limit reached in eighteen months needs a design conversation. A limit reached in six weeks needs a ticket today.
- Raise lead time and ceiling. Some limits rise with a self service request in minutes. Others need a support case, a justification, and days. A few are effectively fixed for a given architecture, and the only real answer is to shard or redesign. Knowing which is which, before the incident, is the whole point.
- Failure mode on reaching it. Rejected change, dropped packets, throttled API, or silent slowdown. The failure mode decides the alert. A rejected change can be caught in a deployment pipeline. A silent slowdown needs active measurement of the resource itself.
Keep the inventory next to the architecture diagram and review it when either changes. A new region, a new tenant model, or a new data path invalidates old headroom quietly.
Design moves that buy real headroom
When a limit is approaching, four responses cover most cases, in roughly this order of preference:
- Summarise and aggregate. Route summarisation is the oldest example. Advertising one aggregate route instead of hundreds of specific ones can cut route table pressure by an order of magnitude and simplify the design at the same time. The same instinct applies to firewall rules built from grouped ranges instead of one rule per address, and to load balancer targets registered through a service layer rather than individually.
- Remove a layer of indirection that consumes the scarce resource. Per service private endpoints, per tenant peerings, and per workload tunnels all scale linearly with growth and hit count limits early. A shared services pattern, where many workloads use one well sized path, trades a small amount of isolation theatre for a large amount of headroom. Where isolation is genuinely required, keep it for the workloads that need it, not for every workload by default.
- Shard deliberately. Splitting traffic across multiple gateways, NAT devices, or hubs works, but only if the sharding key is stable and the operational cost is counted. Two gateways means two places to monitor, patch, and misconfigure. Shard when the numbers require it, not as a reflex.
- Request the raise early, with evidence. Providers respond better to a request that shows current usage, growth rate, and a forecast date than to an urgent escalation during an outage. File the request when headroom crosses a threshold, commonly around sixty to seventy percent for limits with long lead times, while a redesign is still an option rather than a rescue.
What does not work is discovering the ceiling in production and raising it under pressure, because the limits with the longest lead times are usually the ones that cannot be hurried.
Alert on headroom, and test the ceiling on purpose
An alert that fires when a limit is reached is a notification that the incident has started. Alert instead on projected exhaustion: usage above a set share of the limit, or a forecast date inside the next quarter, whichever comes first. Pair count alerts with direct measurement for throughput and state limits, such as gateway utilisation at peak, NAT port or connection utilisation, and dropped packet counters, because those ceilings announce themselves in metrics before they announce themselves in errors.
Then, in a staging environment that mirrors the production shape, test at least one ceiling deliberately. Fill a route table. Saturate a test gateway. Drive a NAT device toward its connection limit with synthetic sessions. The aim is not bravado. It is to learn what the failure actually looks like in the monitoring stack, so that when it happens for real, the first graph someone opens is the right one and the runbook names the limit, the current value, and the owner who can raise or redesign it.
The design point
Cloud network quotas are not fine print. In a multi-cloud estate they are part of the capacity model, alongside bandwidth and latency, and they deserve the same inventory, forecasting, and alerting. The teams that handle them well are rarely surprised by them, because the exhaustion date was on a chart months before it was in an incident channel.
That kind of quota aware network design and capacity planning across AWS, Azure, Google Cloud, and Oracle estates is part of the work described at CloudVerg, where VergMesh covers multi-cloud networking and VergForge covers platform engineering, alongside zero-trust security through VergShield and SOC 2 readiness support.
A limit reached at 2 AM was almost always visible at 2 PM, months earlier. The difference is whether anyone was measuring it.