Most multi-cloud network changes are reviewed by reading them. Someone opens a pull request that adds a route, widens a firewall rule, or attaches a new subnet, and the review consists of a careful human scanning the diff and deciding that it looks right. Then the change merges, the pipeline applies it, and the first real test is production traffic.

That is a strange way to treat the layer everything else depends on. Application code ships with unit tests, integration tests, and a staging deploy. Network changes, which can quietly cut off a database or open a path nobody intended, often ship with nothing but a second pair of eyes.

A reachability check in CI closes that gap. It does not replace review. It gives review evidence.

What a Reachability Check Actually Is

A reachability check answers one narrow question for a proposed change: after this change is applied, which sources can reach which destinations, on which ports, and has that set changed in any way nobody declared?

The input is the intended state, not the live estate. The pipeline renders the proposed routes, firewall rules, security groups, and network policies into one model, then evaluates a matrix of flows against it. Source workload to database on its data port: allowed. Source workload to database on SSH: denied. Internet to any private subnet: denied. New analytics job to the payment service: denied, because nobody asked for it.

The output is a diff of connectivity, not a pass on a single flow. A change that adds the one flow it was meant to add, and nothing else, passes. A change that adds the intended flow plus three unintended ones fails, even if every individual rule in it looks reasonable in isolation.

That distinction matters because most network incidents are not caused by a rule that was obviously wrong. They are caused by a rule that was broader than the author realised, a route that summarised further than expected, or a default that changed meaning when it landed in a second cloud.

Build the Matrix From Reality, Not From Hope

The matrix is the hard part, and it should be built from what the estate actually does.

Start with the flows production depends on. Flow logs, load balancer records, and service inventories show which workloads talk to which databases, queues, registries, and endpoints, and on which ports. Each of those becomes a required flow that must stay allowed after any change.

Then add the flows that must never exist. Private subnets reachable from the internet. Management ports reachable from workload networks. One tenant or environment reaching another. Regulated data stores reachable from general purpose compute. These denied flows are the security posture stated as tests, and they catch the changes that succeed at their goal while quietly breaking a boundary.

Keep the matrix in version control beside the network code. When a team legitimately adds a new dependency, they add the flow to the matrix in the same pull request, where a reviewer can see the intent stated plainly. The matrix becomes a readable record of what the network is for, which is documentation most estates do not otherwise have.

Run It Where the Change Is Proposed

The check belongs in the pull request pipeline, before merge, on the rendered plan rather than on hand written source files.

Rendering matters because clouds interpret the same intent differently. A rule that is scoped to one subnet in one platform may attach to a whole network in another. A route table association that looks optional in code may be the thing that decides whether a subnet is private at all. Testing the rendered, provider specific plan is what catches translation errors between clouds, which are exactly the errors a human reviewer is worst at spotting in a diff.

The failure output should read like a test failure, not a policy lecture. Name the flow that changed, show whether it was required, denied, or undeclared, and point at the resource in the plan that caused it. A check that only says non compliant will be bypassed within a month. A check that says this change makes the reporting job able to reach the payment database on port 5432, which no declared flow allows, gets fixed.

Handle the Estate You Have

Few estates can adopt this strictly on day one. The existing matrix will fail against the existing network, because real networks carry years of flows nobody declared.

Start in report only mode. Run the check on every network pull request and publish the connectivity diff as a comment, without blocking the merge. For a few weeks the diff teaches the team what a change really does, and the matrix gets corrected where it was wrong and completed where it was thin.

Then enforce in layers. Block first on the never flows, the denied set that protects private and regulated paths. Those should be uncontroversial. Block next on undeclared new flows, while still only warning when a required flow disappears during a planned migration. Within a quarter, most teams find the check has become the fastest way to understand a change, not a gate they resent.

Grandfather the legacy flows explicitly, with an owner and a review date, rather than silently allowing everything that exists today. An undated exception is just a wider rule with better paperwork.

What This Catches That Review Does Not

It catches the summary route that also covers a subnet nobody mentioned. It catches the security group copied from another environment with one extra source range still in it. It catches the second cloud enforcing a translated rule in the opposite direction from the first. It catches the change that removes a route a batch job needs once a night, which no daytime reviewer would miss until the job fails.

It also changes the conversation in review. Instead of debating whether a rule looks safe, reviewers look at the declared flows and the connectivity diff, and debate whether the intent is right. That is a better use of a senior engineer than mentally simulating route tables.

This kind of pre merge reachability testing is a regular part of the private connectivity design work at CloudVerg, where multi-cloud estates built on VergMesh and reviewed through VergShield treat the connectivity diff as required evidence for every network change, so what a change does to reachability is known before it is applied rather than discovered by the first workload that crosses it.

A network change is not reviewed when someone has read it. It is reviewed when its effect on who can reach what has been computed, compared with intent, and recorded. Ship the test with the route, and the diff stops being an opinion.