Preprint
Concept Paper

This version is not peer-reviewed.

A Conceptual Framework for Evaluating Static and Dynamic Kubernetes NetworkPolicy Validation in GitOps Pipelines: A Literature-Based Study

Submitted:

11 November 2026

Posted:

13 November 2026

You are already at the latest version

Abstract
Kubernetes NetworkPolicy resources are the native mechanism for restricting traffic to and from pods, but a NetworkPolicy is a declaration of intent, not a guarantee of enforcement. Enforcement depends on the CNI plugin, and in a GitOps pipeline, where policies are stored in Git and reconciled automatically, a manifest that passes review can still produce no isolation at runtime. This literature-based study reviews what is known about two validation families (static, which inspects manifests before they reach the cluster, and dynamic, which tests connectivity inside a running cluster) and identifies four gaps: the divide between static and dynamic validation, the handoff gap between pre-apply and post-sync phases, the missing link between known misconfiguration patterns and the gates that might catch them, and the absence of a reproducible test oracle for dynamic testing. From this review we derive a four-layer conceptual framework (manifest-level static validation, offline semantic validation, runtime dynamic validation, and continuous verification inside the reconciliation loop) as an organising model for practitioners and an agenda for empirical work. The framework synthesises existing approaches and has not been implemented or tested.
Keywords: 
;  ;  ;  ;  ;  ;  

1. Introduction

Kubernetes clusters are open by default. Pods can reach one another across namespaces unless a NetworkPolicy selects an endpoint and restricts traffic (Kim et al., 2025). For a developer this is convenient; for a security team it is a standing problem, since a single compromised container becomes a foothold for lateral movement, scanning, and exfiltration. Network policies are widely recommended as a baseline control, and empirical studies of Kubernetes manifests find security misconfigurations to be prevalent in practice (Rahman et al., 2023). The concern is not hypothetical.
The GitOps model changes how these policies are managed. Desired state is declared in version-controlled repositories and reconciled into the cluster by a controller (Beetz & Harrer, 2022). Auditability, review workflows, and rollback follow naturally. What also follows is an assumption that a policy committed to Git, reviewed, and successfully synced is a policy in force. The platform does not guarantee that. A NetworkPolicy is a statement of intent; the API server accepts and stores the object whether or not any component in the cluster can enforce it. CNI plugins differ in the NetworkPolicy features they support, and performance characteristics vary across implementations (Kim et al., 2025; Budigiri et al., 2021). Declarative YAML is evidence of what an operator wants. It is not proof of what the data plane does.
Two validation families have grown up around this problem. Static validation inspects manifests before they are applied: schema checks, policy-as-code engines, linters, and offline analysis of the policy set. Dynamic validation observes the running system, sending real traffic between workloads and comparing the outcome against an expectation. The two families rest on different kinds of evidence. Static approaches reason about the form and declared meaning of artefacts; dynamic approaches observe behaviour. How the two relate, and where each sits in a GitOps delivery pipeline, is only partly articulated in the literature.
This study is a literature-based synthesis. It reports no original experiments and no primary data, and its contribution is a conceptual framework rather than an empirical evaluation. The review addresses four questions:
1.
What static approaches are used to validate Kubernetes NetworkPolicies?
2.
What dynamic approaches are used to verify their runtime enforcement?
3.
What are the strengths, blind spots, and complementary roles of each approach?
4.
How can these approaches be organised into a framework aligned with GitOps workflows?
The framework is derived from the reviewed literature. Its usefulness remains a question for future work.

2. Review Method and Scope

This is a targeted narrative review rather than a protocol-driven systematic review. Sources were identified through searches of Google Scholar, IEEE Xplore, the ACM Digital Library, and publisher landing pages, using combinations of the terms “Kubernetes NetworkPolicy”, “CNI”, “GitOps”, “policy-as-code”, “network policy verification”, and “Kubernetes misconfiguration”. Searches were run in November 2026 and covered work published between 2009 and 2026. Inclusion required a peer-reviewed journal article or conference paper addressing Kubernetes networking, network policy validation, cloud-native configuration security, or GitOps delivery. Vendor documentation and practitioner material were consulted for context but are not cited as evidence for empirical claims.
Screening was by title and abstract, followed by full-text reading. Because the review is narrative, no formal inclusion counts, inter-rater agreement statistic, or quality-appraisal instrument is reported. The retained sources were grouped by the kind of evidence they produce (static analysis, offline reachability, runtime testing, continuous verification), and the four-layer framework in Section 6 was derived from that grouping. Section 9 discusses the limitations that follow from this approach.

4. Review of Static Validation Approaches

4.1. Schema Validation and Linting

The lowest layer of static validation checks that a manifest is well formed. Schema validators confirm that a document conforms to the Kubernetes OpenAPI definition for its declared version, catching misspelled fields, wrong types, and deprecated API versions. Linters extend this with heuristics about common structural mistakes: empty or overly broad selectors, policies that select no pods because of label mismatches against known workloads, and ingress or egress sections that are present but empty in ways that change meaning. Such checks are cheap, fast, and deterministic, which makes them well suited to pre-commit hooks and pull request gates. Their evidentiary scope is narrow. A document can be schema-valid and lint-clean while expressing an intent that is wrong, or an intent that nothing will enforce.

4.2. Policy-as-Code with OPA, Conftest, and Kyverno

Policy-as-code adds organisational semantics to this. Open Policy Agent provides a general-purpose engine and the Rego language, and Conftest applies Rego policies to structured configuration files, which makes it convenient inside CI pipelines (Nogueira & Resende, 2026). A typical use is a rule that fails the pipeline when a namespace lacks a default-deny NetworkPolicy, or when a policy permits ingress from all sources. Kyverno offers a Kubernetes-native alternative in which validation rules are themselves Kubernetes resources, applied both in admission control and against manifests offline. Admission-time enforcement, whether by Kyverno or by another engine, blurs the line between pre-apply and in-cluster validation. It runs in the cluster but still evaluates the submitted object, not the resulting network behaviour. For present purposes we classify it as static, because the evidence it relies on is the declared resource.
What policy-as-code is good at is making institutional requirements explicit, versioned, and enforceable at the point of change. Its characteristic limitation is that rules can only test what is expressed in the manifest. A rule can establish that a default-deny policy exists in a namespace. It cannot establish that the CNI is enforcing it.

4.3. Offline Reachability Analysis

A more ambitious class of static approaches models the effect of a policy set without a running cluster. Helm-ET analyses Helm-packaged applications statically, derives network policies from the deployment artefacts, and computes reachability between services without deploying them (Bufalino et al., 2025b). The approach is faster than live probing and applies policies before application deployment. Its central limitation is that it models intent according to the specification, or according to the author’s reading of it. Where a CNI deviates from the specification, supports only a subset, or carries implementation defects, the model and the data plane diverge, and offline analysis cannot see the divergence.

4.4. Reported Limitations of Static Validation

Across these approaches, the literature converges on a common boundary. Static checks verify manifest structure and organisational policy, and in the case of offline reachability analysis they verify the logical consequences of declared policy. They do not verify that the cluster enforces what is declared. A manifest can pass every static gate and remain inert if the CNI is absent, if the plugin does not implement NetworkPolicy, if a feature is unsupported, or if configuration at the node or plugin level is wrong (Kim et al., 2025). Bufalino et al. (2025a) go further. They report that existing security tools, including many that operate on configuration, inherit the limitations of ambiguous guidance and fail to detect many network-layer misconfigurations, particularly those that arise from the interaction between application configuration and cluster networking.

5. Review of Dynamic Validation Approaches

5.1. Post-Deployment Connectivity Testing

Dynamic validation treats the cluster as an experimental subject. A test asserts that traffic from a specified source to a specified destination on a specified port is either permitted or blocked, executes the connection attempt, and compares the outcome against the assertion. A recent example is the multi-agent pipeline of Mahmood and Song (2026), which generates NetworkPolicy candidates, deploys them to a live cluster, and runs real connectivity tests between probe pods to verify enforcement. The approach catches semantic errors that static analysis cannot detect. Two limits are worth noting: the evaluation runs on a single-node Kind cluster over a limited set of policy patterns, and the expected connectivity outcomes are derived from the policy YAML itself, so the oracle is not independent of the artefact under test.

5.2. Ephemeral Probes and Declarative Test Specifications

A second line of tooling emphasises declarative test specifications and minimal intrusion. Test definitions can be versioned alongside the policies they exercise, and execution can be tied to post-deployment hooks so that a failed probe fails a Kubernetes job and thereby signals a failed rollout. The reviewed literature describes such pipelines in general terms, and the pattern is compatible with GitOps controllers that support hooks (Beetz & Harrer, 2022). Probe-based analysis has also been applied to corpora of Helm-packaged applications, which allows access and isolation between microservices to be assessed at scale (Bufalino et al., 2025a).

5.3. CNI-Specific and Conformance Testing

A third category evaluates the CNI itself rather than any particular application policy. CNI conformance testing checks a plugin’s behaviour against the NetworkPolicy specification, and comparative studies of CNI plugins show that implementations differ in the features they support and in their performance characteristics (Kim et al., 2025; Budigiri et al., 2021). This category differs from application-level probing in its target. It validates the enforcement substrate, which is a precondition for any policy-level assurance.

5.4. Strengths and Reported Costs

What dynamic validation offers, and what makes it worth its cost, is direct evidence. A passing probe shows that an actual connection was or was not established under the actual CNI, with the actual labels, in the actual cluster. This directly addresses the weakness of static approaches, since an inert policy, an unenforced feature, or a mislabelled selector will cause a probe to disagree with the assertion.
The reviewed material also records the costs. Dynamic tests require a running cluster, and therefore a way to provision or reach one from the pipeline, along with permissions to create probe workloads or ephemeral containers. They are slower than static checks, and their execution time grows with the number of workload pairs and ports probed. Results depend on timing and environmental state, which gives rise to the flakiness that anyone running connectivity tests in shared clusters will recognise. Dynamic tests also have an intrinsic coverage limitation. They test only the connections actually probed, and the absence of a detected violation is not proof of complete isolation, because an unprobed path may remain open. Finally, a probe is only as informative as its expectation. If the expected result is itself derived from a flawed reading of the policy, the test confirms the flaw.

6. Gaps and Tensions Identified in the Literature

Four gaps cut across the literature reviewed here. They overlap, and no attempt is made to treat them as independent. Each does, however, point at a different kind of missing work.
Take the static-dynamic split first. Static tools verify form, and offline analysers verify the logical consequences of declared policy, while dynamic tools verify behaviour. Neither verifies both. The literature typically presents the two families in separate bodies of work, with static verification research focusing on offline analysis and reachability modelling (Bufalino et al., 2025b) and dynamic validation work focusing on live-cluster testing (Mahmood & Song, 2026). Explicit comparison of what each family can and cannot detect on a common set of defects is largely absent from the reviewed sources.
The GitOps handoff is the second gap. Most static checks run before sync, in pull request pipelines or admission control, and most dynamic checks run after sync, as hooks or scheduled jobs. What happens between the two is underspecified. Questions that practitioner descriptions leave open include whether a static pass should be recorded as a precondition for dynamic testing, whether a dynamic failure should trigger automated rollback or only an alert, how the two results should be attached to the same commit or release for auditability, and how long a policy may be live and untested. GitOps tooling provides hooks, but not a model of how evidence from the two phases is combined.
Third, the literature catalogues misconfiguration patterns but does not connect them to the gates that would catch them. Missing network policies, containers bound to the host network, and unintended exposure of ports have been classified in some detail (Bufalino et al., 2025a), and misconfigurations in open-source Kubernetes manifests have been analysed empirically (Rahman et al., 2023). What is missing is the mapping. For a given misconfiguration pattern, the literature rarely states whether schema validation, a Rego rule, offline reachability analysis, or a runtime probe would detect it, or which combination would be required. The mapping from pattern to detecting mechanism remains informal.
The fourth gap concerns reproducibility. Dynamic tests are environment-dependent: their outcomes depend on the CNI and its version, kernel and node configuration, cluster topology, timing, and workload state. The literature rarely standardises the test oracle, by which we mean the authoritative statement of what traffic should be allowed. In application-level practice, expectations are typically hand-written alongside policies, so a mistaken understanding can end up encoded in both. Reproducible benchmarks that would allow different validation gates to be compared on common cases are likewise not evident in the reviewed sources.

7. Proposed Conceptual Framework

The framework presented here is a structured comparison model, not an implemented system. It synthesises the approaches reviewed above into four layers, each defined by the kind of evidence it produces. No claim is made that the layers are novel individually, or that the framework has been tested. Table 1 summarises the four layers and is a synthesis of the reviewed material, not an experimental result.

7.1. Layer 1: Manifest-Level Static Validation

Manifest validation, the innermost layer, treats each manifest as an artefact to be checked. It comprises schema validation against the Kubernetes API definitions, linting for structural errors, and policy-as-code checks written in Rego for use with Conftest or as Kyverno validate rules (Nogueira & Resende, 2026). What it validates is that documents are well formed and that they satisfy organisational requirements such as the presence of default-deny policies or the absence of unrestricted ingress. It assumes that manifests accurately represent what will be applied, that rules reflect the organisation’s real requirements, and, implicitly, that the cluster and its CNI will behave as the API specification states. It cannot catch an inert policy, an unsupported feature, a CNI that does not enforce NetworkPolicy, or semantic errors that depend on the interplay of several policies and on labels defined elsewhere. In a GitOps workflow it sits at the earliest points: editor tooling, pre-commit hooks, and pull request checks. Admission-time policy engines form a second, in-cluster instance of the same layer.

7.2. Layer 2: Offline Semantic Validation

Offline semantic validation goes a step further by reasoning about the combined effect of a policy set together with workload and namespace labels, without a live data plane. Reachability models and static analysers such as Helm-ET belong here (Bufalino et al., 2025b). What gets validated is a class of invariants: the absence of unintended reachability between tiers, the detection of conflicting or shadowed rules, and the consequences of a proposed change before it is applied. The assumptions are that the model’s semantics match the specification, that its inputs (pod labels, namespace metadata) accurately represent the cluster, and, in multi-CNI environments, that vendor-specific extensions are correctly normalised. What this layer cannot do is detect divergence between the specification and the CNI’s actual behaviour. It models intent, not runtime behaviour. In GitOps it sits in pull request or pre-sync stages, where it can consume the proposed manifests together with a snapshot or description of workloads.

7.3. Layer 3: Runtime Dynamic Validation

At the third layer, the cluster itself becomes the test subject. Validation here means generating traffic in a running cluster, which may be an ephemeral test cluster provisioned by CI or a staging environment. Connectivity test generation, ephemeral probe containers, declarative tests, and CNI conformance suites all belong to this category (Mahmood & Song, 2026; Kim et al., 2025). The layer validates that the combination of manifest, labels, CNI, and node configuration produces the expected allow and deny outcomes for the specific connections tested. It assumes a representative cluster, appropriate permissions for probes, stable timing, and a correct test oracle. Its limits are that it cannot demonstrate complete isolation, since it covers only the probed paths, and that results from a test cluster may not transfer to production if the CNI version or configuration differs. In a GitOps workflow it sits after rendering and deployment into a non-production target, or as a post-sync hook. Its position determines whether a failure blocks promotion or only reports after exposure.

7.4. Layer 4: Continuous Verification

The outermost layer, continuous verification, extends validation across time and integrates it with the reconciliation loop. It comprises post-deployment checks tied to sync or helm hooks, scheduled probe jobs, and health or drift checks associated with the GitOps controller (Beetz & Harrer, 2022). The property it protects is that isolation continues to hold after the initial rollout: through CNI upgrades, label changes, node changes, and manual interventions that the controller later reverts or fails to detect. It assumes that tests remain current with the policies they exercise, that results are surfaced to someone empowered to act, and that the cadence of verification is adequate relative to the rate of change. What it cannot do by itself is explain why a check failed or which earlier layer should have caught the defect. In GitOps it sits inside or alongside the reconciliation loop, producing signals that feed alerts, rollback decisions, or tickets.

7.5. Complementarity of the Layers

The layers are complementary rather than substitutable, because each covers blind spots of the others. The innermost layer is cheap and early but sees only form and local rules. Layer 2 adds cross-policy reasoning but trusts the specification. Layer 3 observes the real enforcement substrate but covers only sampled paths and costs time and infrastructure. Layer 4 adds temporal coverage but inherits the sampling limits of Layer 3. A defect that escapes one layer may be visible at another: a missing default-deny policy is naturally a Layer 1 finding, an unintended path created by overlapping selectors is naturally a Layer 2 finding, and a policy that is present, correct, and ignored by the CNI is visible only at Layers 3 and 4. A framework that reports which layers have evidenced a given isolation claim therefore gives a more accurate picture than any single pass or fail signal. Used this way, the framework becomes a comparison model. For any proposed validation pipeline, a practitioner can ask which layers it covers, what each assumes, and what residual risk remains.

8. Implications for Research and Practice

What follows is derived from the literature review and the framework; none of it is a finding from experiments.
For practitioners, the main implication is that static and dynamic validation should be treated as complementary gates rather than alternatives. The reviewed literature shows that static checks cannot establish enforcement while dynamic checks cannot establish completeness. A pipeline that includes only manifest linting and policy-as-code provides assurance about form and organisational conformance but leaves the enforcement question open. A pipeline consisting only of post-deployment probes catches defects late, after the policy is live, and probes only those connections someone thought to specify. A pragmatic reading of the framework is that inexpensive Layer 1 checks should run on every change, that offline semantic analysis should be applied where policy sets are large or label-driven enough for human review to be unreliable, and that dynamic probes should cover at least the isolation properties that matter most: default-deny behaviour between tenants and access to sensitive services, for example. Teams should also verify the enforcement substrate itself, since comparative studies show that CNIs differ in the features they implement and in their performance (Kim et al., 2025; Budigiri et al., 2021). The handoff between phases deserves explicit design. Practitioners may wish to decide in advance whether a post-sync failure triggers rollback, how test definitions are versioned together with policies, and how evidence from each layer attaches to a release record. Where tests and policies are authored by the same person from the same understanding, an independent source of expectations (a stated security requirement, or a conformance-derived oracle) reduces the risk that a shared error passes unnoticed.
For researchers, the review points to two needs. First, the literature lacks a shared taxonomy that connects misconfiguration types to validation coverage. Catalogues exist (Bufalino et al., 2025a; Rahman et al., 2023), and validation tools exist, but the mapping between them has not been systematically established. Constructing and empirically testing such a mapping is a natural next step. Second, the literature lacks reproducible benchmarks for comparing validation gates. A benchmark would need a corpus of policy sets with known defects, specified CNI configurations, and a standardised oracle, so that the detection capability of linters, policy-as-code rules, offline analysers, and probes could be compared on common ground. Related questions include the cost and flakiness of dynamic tests under different cluster conditions, the transferability of results from test to production clusters, and the effectiveness of different handoff designs in GitOps pipelines. Answering any of these would require empirical methods that this study does not employ.

9. Limitations of This Literature-Based Study

The conclusions here are bounded by several limitations. The most obvious is that the study is literature-based and includes no primary experiments. Statements about the strengths and weaknesses of validation approaches are drawn from published descriptions; no detection rates, performance figures, or comparative results are reported. Where the reviewed sources describe costs such as slower execution or flakiness, these are reported as characterisations in the literature, not as measurements made here.
The review is also not exhaustive. It was not conducted as a protocol-driven systematic review of the kind described by Kitchenham et al. (2009), and it may miss relevant work on particular CNIs, particular GitOps tools, or particular validation products. Work published in venues or languages not examined here, and work that appeared after the review was completed, may also be missing. The treatment of Argo CD and Flux is representative of the two most prominent GitOps controllers but does not extend to all alternatives.
A further limitation is that the framework is conceptual. It has not been implemented, applied to a real pipeline, or empirically validated, and its layers and boundaries reflect one reasonable way of organising the material. Other decompositions are possible, and the placement of some mechanisms involves judgement. Admission-time policy engines, for example, operate in the cluster but on declared resources; classifying them as static is defensible but not the only defensible choice. Practitioners should treat the framework as a thinking aid, not as a validated method.
Publication bias and grey-literature coverage are concerns too. Academic venues tend to report novel verification techniques more readily than operational experience, while much of the knowledge about dynamic testing in GitOps resides in vendor blogs, documentation, and repositories. These sources vary in rigour, may reflect commercial interests, and are not peer reviewed. Some of the sources cited here are recent, and their long-term citation record is not yet established. The conclusions should be read with these constraints in mind.

10. Conclusion

This study has reviewed how the literature addresses the validation of Kubernetes NetworkPolicies in GitOps pipelines. The reviewed landscape divides into static approaches (schema validation, linting, policy-as-code, offline reachability analysis) and dynamic approaches (generated tests, ephemeral probes, CNI conformance suites). Static approaches are early, cheap, and automatable, and offline analysis extends them to reasoning across policy sets, but all of them evidence intent rather than enforcement. Dynamic approaches evidence behaviour but only for the connections probed, at higher cost, with sensitivity to the environment and to the quality of the test oracle. The literature identifies the importance of both, yet leaves the relationship between them, and their placement in GitOps reconciliation, largely implicit.
The four-layer framework proposed here (manifest-level static validation, offline semantic validation, runtime dynamic validation, and continuous verification) is offered as an organising model. For each layer it makes explicit what is validated, what is assumed, what cannot be caught, and where the layer sits in a GitOps workflow. This lets practitioners ask what evidence supports a given isolation claim and what residual risk remains. It also lets researchers locate gaps in the evidence base. The framework is a synthesis of existing approaches; it has not been implemented or empirically validated, and it should be read in that light.
The most pressing open question that emerges is how to connect known misconfiguration patterns systematically to the validation gates that can detect them. The literature offers catalogues of what goes wrong with network configuration in Kubernetes and a growing toolbox for checking policies, but the mapping between the two is informal. A validated mapping, accompanied by reproducible benchmarks and a standardised test oracle, would let the complementarity argued for here be tested instead of asserted. It would also give GitOps teams a principled basis for deciding which gates a given risk requires.

Author Contributions

Both authors contributed to the conception of the study, the literature search, the synthesis, and the drafting and revision of the manuscript. Both authors approved the final version.

Funding

This research received no external funding.

Data Availability Statement

No new data were generated. All sources discussed are cited in the reference list.

Conflicts of Interest

The authors declare no conflicts of interest.

Use of Artificial Intelligence

Generative AI tools were used to assist with drafting and language editing. The authors verified the content, the citations, and the reference details, and take responsibility for the final manuscript.

References

  1. Beetz, F.; Harrer, S. GitOps: The evolution of DevOps? IEEE Softw. 2022, 39(4), 70–75. [Google Scholar] [CrossRef]
  2. Budigiri, G.; Baumann, C.; Mühlberg, J. T.; Truyen, E.; Joosen, W. Network policies in Kubernetes: Performance evaluation and security analysis. In 2021 Joint European Conference on Networks and Communications & 6G Summit (EuCNC/6G Summit); IEEE, 2021; pp. 407–412. [Google Scholar] [CrossRef]
  3. Bufalino, J.; Martin Navarro, J. L.; Di Francesco, M.; Aura, T. Inside Job: Defending Kubernetes clusters against network misconfigurations. Proc. ACM Netw. 2025a, 3(CoNEXT3)(Article 20), 1–25. [Google Scholar] [CrossRef]
  4. Bufalino, J.; Martin Navarro, J. L.; Peltonen, A.; Aura, T. Helm-ET: Reducing exposure to lateral movement in Kubernetes artifacts. In 2025 IEEE 18th International Conference on Cloud Computing (CLOUD); IEEE, 2025b; pp. 109–120. [Google Scholar] [CrossRef]
  5. Kim, B.; Kim, J.; Lee, S. Exploring security enhancements in Kubernetes CNI: A deep dive into network policies. IEEE Access 13 2025, 35322–35338. [Google Scholar] [CrossRef]
  6. Kitchenham, B.; Pearl Brereton, O.; Budgen, D.; Turner, M.; Bailey, J.; Linkman, S. Systematic literature reviews in software engineering: A systematic literature review. Inf. Softw. Technol. 2009, 51(1), 7–15. [Google Scholar] [CrossRef]
  7. Mahmood, U.; Song, W.-C. A self-correcting multi-agent LLM pipeline for verified Kubernetes network policy. IFIP Networking 2026. 2026; Available online: https://opendl.ifip-tc6.org/db/conf/networking/networking2026/1571260960.pdf.
  8. Nogueira, L.; Resende, A. Reusing policy-as-code across CI/CD and Kubernetes admission control: An empirical assessment of governance consistency. Computers 2026, 15(7), 453. [Google Scholar] [CrossRef]
  9. Rahman, A.; Shamim, S. I.; Bose, D. B.; Pandita, R. Security misconfigurations in open source Kubernetes manifests: An empirical study. ACM Trans. Softw. Eng. Methodol. 2023, 32(4)(Article 99), 99:1–99:36. [Google Scholar] [CrossRef]
Table 1. The four validation layers, the evidence each produces, and its principal limitation.
Table 1. The four validation layers, the evidence each produces, and its principal limitation.
Layer What it checks Evidence produced Main limitation
1. Manifest-level static Schema, selectors, policy rules Configuration conformance Cannot prove enforcement
2. Offline semantic Combined policy and label effects Modelled reachability Depends on model and input accuracy
3. Runtime dynamic Actual connectivity Observed allow/deny behaviour Covers only tested paths
4. Continuous verification Behaviour over time Repeated runtime evidence Inherits test coverage limits
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.