When you remember.
A calendar reminder and a runbook. It works until the quarter you forget — or the 2am page when a token quietly expires in production.
Ward watches every managed credential age, mints a fresh one on the schedule you declare, rolls it out to the systems that use it, and retires the old one — recording each step. The secret value itself never lives in the operator.
Rotation isn't hard. Remembering to, and finishing it when something breaks halfway — that's the hard part.
A calendar reminder and a runbook. It works until the quarter you forget — or the 2am page when a token quietly expires in production.
A cron job that mostly works. When it dies mid-run it has no memory of where it stopped, and you're left guessing which half of the swap actually happened.
You declare the policy once. A crash-safe state machine does the swap, keeps the old key valid until the new one is verified, and writes down every step.
Every long-lived key is a blast radius that only grows. Ward turns rotation from a chore you postpone into a property of the cluster — constant, boring, and auditable.
Five beats, scheduled or triggered by hand with wardctl. There's no window where nothing works.
You write policy. The core runs the loop. Adapters touch the real systems. The split is the point — a mistake in one can't leak a secret from another.
Set the cadence, the shape of generated values, and which stores and adapters are even allowed. A managed credential points at a policy and says where its result is delivered.
CredentialPolicy — cadence, length, max-age, allow-listsManagedCredential — what to manage, where to deliverEvery operation — bootstrap, adopt, rotate, recover, decommission — runs as a strict state machine. Each effect is recorded before it happens, so a crash resumes at the exact boundary.
Each system — Grafana, Redis, your own service — has its own adapter in its own least-privilege process. It does the step it's told to, reads by reference, and reports back by version ID.
Rotating credentials is easy until the one time it half-finishes. These aren't bolted on — they're how the thing is put together, and each is covered by the test suite.
Credential bytes live in exactly one guarded type. A leak-detecting test fails if a value ever reaches a log, an event or a resource status.
Every step is written down before it changes anything real. A pod can die mid-rotation and the engine resumes from the exact boundary, not a guess.
Once a step has touched the target, failure either rolls back — only when the adapter declared that safe — or stops for recovery. It never assumes.
The old credential stays valid until the new one is verified working. Rotation never leaves a window where nothing authenticates.
OpenBao in dev and CI, GCP Secret Manager in production — same contract. Every backend passes one shared conformance suite before it can land.
Each adapter runs under its own ServiceAccount and RBAC, advertises its capabilities, and is approved by an admin before it can act.
Pluggable at both ends: where secrets are kept, and where they're used.
The dev and CI backend. Vault-compatible, never a production requirement.
The production target, behind the same SecretStore interface.
Delivered only where a ManagedCredential explicitly names it. Never adopted implicitly.
In-tree adapters, plus a fake for tests — each built on the public SDK.
Write one with sdk/adapter and prove it with the conformance suite.
Request a rotation and read credential health — without ever printing a value.
A Kubernetes operator that keeps credentials fresh across your real systems — crash-safe, auditable, and built so it can never become the thing that leaks them.