Spot the risks in your Kubernetes YAML before you apply it.

Paste a manifest — get a risk score plus plain-English fixes for privileged containers, root users, missing limits and more. Checked entirely on your device.

  • Your manifest data never leaves the device
  • Multi-document YAML · up to 10 files
  • Risk score + downloadable report
  • Heuristic checks, not a cluster audit

Paste a Kubernetes manifest or add your files

Paste one manifest or a whole multi-document file. Deployments, StatefulSets, DaemonSets, Jobs, CronJobs, Pods, Services, Secrets, Ingresses and RBAC roles are all understood.

Try a sample:

Drag & drop YAML files here

or browse your files

Checked in your browser — every document is parsed and scored with a plain-English reason and fix. Nothing is uploaded.

    No text or files yet. Everything stays on this device. Reports download instantly.

    Privacy you can verify, not just trust

    Your manifests describe your infrastructure — which services you run, which images, which secrets, which hosts. Sending them to a hosted scanner means handing that map to a stranger's server. This one can't: your text and files are parsed entirely in your browser. Your file data never leaves the device — the only third-party requests are the site's own analytics, which count page views — and it uploads nothing, ever. There is no file fetched after load for the inspection itself. Don't take our word for it:

    New cross-origin requests during use: 0
    1. Press F12 to open developer tools, then the Network tab.
    2. Inspect a manifest above. Watch: apart from the site's analytics, nothing new is requested — no uploads, and no file data ever leaves your device.
    3. Extra credit: disconnect your internet after this page loads — inspecting still works.

    How to inspect Kubernetes YAML without uploading it

    A Kubernetes manifest is a security decision written in YAML. The dangerous settings — privileged: true, a container running as root, a hostPath mount on the Docker socket — are one line each, and they are exactly the lines that get copied from a tutorial and never revisited. Catching them after the apply means an incident; catching them before costs a paste.

    This tool checks the manifest where it already is: on your own device. When you paste a manifest or drop a YAML file here, your browser:

    1. Parses every document — multi-document files separated by --- are split and checked one by one, with a small built-in YAML parser that covers the block mappings, sequences, quoted and plain scalars, flow collections and block scalars that real manifests use.
    2. Runs the risk checks per container — privileged mode, root user, host namespaces, missing limits and requests, :latest images, missing liveness and readiness probes, dangerous capabilities, secrets in plain environment variables, hostPath mounts, seccomp and read-only root filesystem settings — plus pod-level, Service, Secret, Ingress and RBAC checks.
    3. Scores and explains — every finding carries a severity, a plain-English explanation of why it matters, and a suggested fix with a line number, and the whole inspection rolls up into a risk score out of 100 and a downloadable report.

    What makes this inspector different

    The established scanners in this space are command-line tools — Kubesec, KubeLinter, kube-score — which you install and run in a terminal or CI. The hosted services that accept a paste either send your manifest to their server or check only syntax and schema. The browser tools that do exist check a narrower rule set: missing limits, missing probes and :latest tags, without the securityContext checks, the secrets-in-env check, the host-namespace checks or a downloadable report. This page is the only free, fully client-side inspector we found that combines the full security and reliability rule set with a risk score, per-finding fixes and a downloadable report — with no install, no account, no upload, and a live network-request counter so you can verify the privacy claim yourself.

    When is inspecting the right choice — and when is it the wrong one?

    Inspecting is right before a first apply, before a pull request merges a manifest change, and when you inherit a cluster's manifests and want to know what you are running. It is the wrong choice as a substitute for a cluster audit: this tool cannot see your image vulnerabilities, your RBAC bindings, or what is actually running — only what the manifest says. It is also the wrong choice as an admission policy: it reports, it does not block. For that, enforce the same rules with an admission controller.

    Honest limitations

    Heuristic checks, not an audit

    These are widely known hardening rules applied to a static file. They cannot replace kube-bench, kubeaudit, KubeLinter, or an admission policy — and a clean score means none of these checks fired, not that the manifest is secure.

    It never sees your cluster

    The tool cannot check image vulnerabilities, RBAC bindings, NetworkPolicies, or what is actually running. A manifest can pass every check here and still deploy a vulnerable image.

    Templates are not evaluated

    Helm and Go template expressions are treated as unknown values, never guessed. Render the manifest first (helm template, for example) and paste the rendered output for a full inspection.

    Anchors and aliases are not resolved

    The built-in parser covers common manifests. Complex anchors, merge keys and unusual flow styles may not parse — the inspection reports what it could not parse rather than guessing.

    Severity weights are judgement

    Critical deducts 20, high 12, medium 6 and low 3. Those numbers are this tool's judgement, documented openly — a team with different risk tolerance may reasonably score the same manifest differently.

    It never changes your files

    This tool only reports and downloads a new report. Your manifest files are never modified — to fix a risk, edit the manifest yourself and re-inspect.

    Frequently asked questions

    Do my manifests upload anywhere?

    No. Your text and files are analysed entirely in your browser — your file data never leaves the device, and the only third-party requests are the site's own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the inspector.

    What risks does it check for?

    Privileged containers, containers running as root, host network, PID and IPC sharing, missing resource limits and requests, :latest or untagged images, missing liveness and readiness probes, dangerous Linux capabilities, secrets in plain environment variables, hostPath mounts, missing seccomp profiles, writable root filesystems, and public LoadBalancer Services — plus RBAC wildcard rules and Secrets stored in manifests.

    What does the risk score mean?

    Every finding deducts points from 100: critical 20, high 12, medium 6, low 3. 90 or above is low risk, 70–89 moderate, 50–69 high, and below 50 critical. The score is this tool's judgement of the checks it runs — a clean score means none of these checks fired, not that the manifest is secure.

    Does it replace kube-bench or kubeaudit?

    No. Those tools audit a running cluster against the CIS benchmarks; this tool reads a manifest before anything runs. It is also not an admission controller — it reports, it does not block. Use it as a fast pre-flight check, then run the cluster-level tools and enforce policy with an admission controller.

    Which Kubernetes resources does it understand?

    Pod, Deployment, StatefulSet, DaemonSet, Job, CronJob, ReplicaSet and ReplicationController for container checks, plus Service, Secret, ServiceAccount, Ingress, Role and ClusterRole for their own checks. Other kinds are listed as checked but get no container findings.

    Can it read multi-document YAML files?

    Yes. Documents separated by --- are checked one by one, and you can drop up to 10 files at once, up to 5 MB each. You can also mix pasted text and files in one inspection.

    What if my YAML uses anchors, aliases or Helm templating?

    Anchors and aliases are not resolved, and Helm or Go template expressions such as {{ .Values.image }} are treated as unknown values, never guessed. Templated fields simply do not produce findings. Render the manifest first (helm template, for example) and paste the rendered output for a full inspection.

    Why does it flag a missing resource limit as high risk?

    Because without CPU and memory limits, one misbehaving container can starve every other workload on the node, and a memory leak becomes a node outage. Limits are the cheapest reliability control in Kubernetes, and they cost one block of YAML per container.

    What does this tool NOT do?

    It does not talk to your cluster, scan container images for vulnerabilities, check your RBAC bindings, or evaluate Helm charts and Kustomize overlays. It cannot see what is actually running — only what the manifest says. For a full audit, use a dedicated scanner and a cluster-level tool.