Get rid of magic ifs governing your app
Move pricing rules, feature gates, tenant limits, RBAC and kill switches out of your code and into a signed policy bundle. Your app evaluates it locally, no network call in the request path, no account, no lock-in.
Pricing tiers. RBAC. Regional restrictions. Rate limits. Feature access. That emergency switch someone added at 3 a.m. and never removed.
Every one of them is a conditional buried in a service, invisible to the people accountable for it, and changeable only by shipping new code.
How it works
Policies are authored, built into a bundle, and signed. The bundle is shipped like any other configuration artifact — a Git commit, an object in a bucket, a layer in your image.
Your application loads it once at startup, verifies the signature, and evaluates every decision in memory with minimal overhead.
Policies and rules are just JSON. Schemas are public. Write them by hand or withgovplane policies
govplane build compiles your policy drafts into a single artifact. Sign the bundle with your key during the build process or with govplane sign
A Git commit, an object in a bucket, a layer in your image. Your call.
The SDK validates the checksum and signature at load. Unsigned bundles are refused.
Every call resolves in your process.
No network, no round trip, nothing to be down.
Govern your app through a fully open-source tool.
CLI and SDK packages are open sourced. The bundle specification is public and everything will stay that way.
If our infrastructure were to disappear tomorrow, you could still create bundles and your policies would be assessed in the same way as they are today.
Govplane is MIT licensed (CLI, CLI Toolkit and the SDK). The bundle format is published. You can run all of it, in production, forever, without paying us and without an account.
Write a bundle by hand, sign it with your own key management, and evaluate it with the SDK. You never have to run our build tooling at all.
Run the CLI and the SDK in the absence of a network connection.
The CLI Toolkit extension for the CLI requires activation and nothing else. After activation the toolkit never contacts us again.
CLI
validate and inspect any draft or bundle, whoever built it. Zero runtime dependencies. The only command that can reach the network is version --check, and only when you pass the flag.
CLI Toolkit
build, sign, simulate, analyze, and policies.
Activation asks you to accept the terms and nothing else. An email address is optional*.
No telemetry, no heartbeat, no license check, no machine binding. After activation the toolkit never contacts us again. It works on air-gapped machines and across every machine you own.
Runtime SDK
Evaluation happens inside your process, from a file on disk: no account, no credentials, no network call in the request path.
A client always holds a verified bundle — the first load and signature check happen before it's constructed, so evaluate() can never run against nothing. It's the same package whether the bundle comes from your disk or from Govplane Cloud, so nothing you write today has to change if you ever move.
MIT licensed, zero runtime dependencies, Node.js 20.19 or later.
Currently only available for Node.js:
The SDK for Java, Python, and PHP is only available in version 1.0 (deprecated). Version 2.0.0 for Java, Python, and PHP is on the way!
Built for Risk-Aware Organizations
Enable product, compliance, and operations teams to act, without waiting for engineering release cycles.
Avoid making hasty changes to critical code. Change your app's behavior using an artifact. Simulate the behavior on your own machine before deploying it.
Enforce regulatory, regional, or contractual constraints dynamically.
As systems grow more distributed, governance becomes more complex. Govplane centralizes and standardizes control.
Instant kill switches and runtime restrictions enable immediate mitigation of integrity threats without the need for emergency codebase deployments.
Policy execution is deterministic, auditable, and version-controlled. Your application behaves consistently and predictably.
Frequently Asked Questions
Is Govplane really free?
Yes. MIT, in production, forever, no user or policy limits. Cloud is a separate, optional paid service.
Do I need an account?
Not for the SDK, not for @govplane/cli, not for @govplane/cli-toolkit and not to write, sign, and run policy bundles.
The CLI toolkit package asks for an email address (optional) during activation so we can send out news about the product, but you don't need to give it if you don't want to.
Govplane Cloud service is optional, and it is the only thing that needs an account.
What if I don't want to install the CLI Toolkit at all?
The spec is public. Write and sign the bundle yourself; the SDK verifies it the same way.
Does my application depend on Govplane's servers at runtime?
No.
All policy evaluations occur locally within your runtime environment. Your application does not require a live connection to Govplane to make decisions. Our infrastructure is never in the critical execution path of your production traffic.
What happens if a policy evaluation fails?
Per-policy defaults, fail-open or fail-closed by choice, deny when nothing matches and no default exists, last verified bundle stays in force on a failed reload.
What is the performance impact of policy evaluation?
Govplane is designed for minimal latency overhead.
Policy evaluations occur locally within your runtime and are optimized for deterministic execution. There is no external API call in the critical request path, eliminating network latency from the decision flow.
In most implementations, evaluation adds negligible overhead compared to typical business logic execution. Governance becomes predictable and controlled — without sacrificing performance.
What's the license?
The CLI, the CLI Toolkit and the SDK are MIT licensed.
CLI -> https://github.com/Govplane/govplane-cli?tab=MIT-1-ov-file
CLI Toolkit -> https://github.com/Govplane/govplane-cli-toolkit?tab=MIT-1-ov-file
SDK -> https://github.com/Govplane/govplane-runtime-sdk?tab=MIT-1-ov-file
Why not build an internal governance or policy engine?
Many organizations initially build internal rule systems or feature management frameworks. Over time, these systems tend to:
- Accumulate technical debt
- Lack proper auditability
- Create architectural coupling
- Require ongoing maintenance
- Become critical but underfunded infrastructure
Govplane provides a purpose-built governance layer designed for scalability, traceability, and operational resilience — allowing your engineering teams to focus on product differentiation instead of maintaining internal control tooling.
Building governance infrastructure is possible.Maintaining it at enterprise scale is the real challenge.
Your runtime stays yours and gets a real-time control plane.
The SDK and CLI are yours, free and open, forever. Govplane Cloud is what you add when policy stops being one engineer's file and becomes something a whole company depends on.
One place where policies live. A record of who changed what. Distribution to every environment without shipping files by hand. Alerts when a policy starts denying traffic it never denied before. Permissions that reflect your org chart. That is Govplane Cloud.