Join our Newsletter — 33% off our NHI Course
Home› FAQ› Cyber Security› What is the difference between a dry run…
Cyber Security

What is the difference between a dry run and a live SDK release?

← Back to all FAQ
By NHI Mgmt Group Editorial Team Updated October 30, 2026 Domain: Cyber Security

A dry run exercises the full generation and build path without opening pull requests or leaving durable changes behind. A live release creates real pull requests, runs repository tests, and can proceed to publication once approvals and checks pass. Teams use dry runs to inspect impact safely, then use the live release path only after confirming the output is correct.

How a dry run differs from a live SDK release

A dry run is the safe rehearsal. It exercises the same generation and build path you would use in production, but it stops short of creating durable change. A live release is the real execution path: it creates pull requests, runs checks that can block progress, and moves toward publication if approvals succeed.

The practical difference is not just whether output is produced, but whether the workflow is allowed to affect the repository. Dry runs are designed to surface bad assumptions, broken templates, and unexpected downstream effects without leaving a trail. Live releases are designed to prove the process can pass real gates and produce an artifact that other teams can consume.

That means a dry run is best treated as a validation step, while a live release is a change event. If the dry run shows a mismatch in generated files, metadata, or release notes, you fix the source of truth before you expose the repository to a real update path. If the live path fails, the failure is meaningful because it reflects the checks and approvals that actually protect publication.

What changes in practice when the run is live?

A live SDK release usually has three practical differences from a dry run. First, it can open or update pull requests, so repository state changes become part of the workflow. Second, it runs tests and approval gates as real release controls, which means a failure can stop publication rather than merely report it. Third, it can produce release candidates or published artifacts that downstream users may rely on.

That shift matters because the live path is where operational friction shows up. Branch protection, review latency, CI availability, and release permissions all become relevant. A dry run tells you whether the automation logic is sound; a live release tells you whether the organisation’s real process, permissions, and checks are aligned with that logic.

For teams maintaining delivery automation, the distinction is similar to using a simulator before touching shared infrastructure. The simulation gives confidence in the path, but only the real release proves that ownership, review, and publication controls work together under production conditions. Google Cloud Organization Policy Guide is a useful parallel example of that safe-rollout pattern, because it shows how dry-run style validation helps teams inspect impact before enforcing change.

How teams should use dry runs before promoting a release

The right workflow is to use the dry run to answer a narrow question: did the tool generate the expected result, and would the live path do anything surprising? Once that is confirmed, the live release should be reserved for output that is already understood, reviewed, and ready to pass through repository controls. A dry run is not a substitute for review, and a live release is not the place to discover basic formatting or packaging errors.

VPC Service Controls Guide is another good analogy for the operating model: test the boundary conditions first, then move to enforced mode only when you are confident the policy behaves as intended. The same logic applies here, because release automation often fails in the seams between generation, repository permissions, and approval gates.

When the release path is mature, the dry run becomes a routine preflight check rather than a separate project. That is the point at which teams can trust the live path to reflect real approvals, real checks, and real publication outcomes.

Risk and Threat Considerations

A dry run reduces accidental change, but it can also create false confidence if teams assume the live path will behave identically. The main risk is drift between the rehearsal and the real workflow: permissions, branch protections, tests, or approval rules may only surface once a live release is attempted.

Failure mechanism: The dry run bypasses durable state changes, so it can miss problems tied to repository writes, protected branches, or publication gates that only exist in the live path.

Impact: Teams may approve a release path that later fails, creates incomplete updates, or exposes an unintended change to consumers at release time.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

CIS Controls v8, NIST CSF 2.0 and OWASP SAMM set the governance and control requirements practitioners need to meet.

FrameworkControl / ReferenceRelevance
CIS Controls v8CIS-4 — Secure Configuration of Enterprise Assets and SoftwareDry vs live release depends on controlled software change paths.
Recommendation — Apply CIS-4 to validate release paths before promoting changes to production.
NIST CSF 2.0PR.PS-05 — Manage replacement and deployment of system componentsRelease promotion is about controlled deployment from rehearsal to live state.
Recommendation — Use PR.PS-05 to govern how release artifacts move from validation into deployment.
OWASP SAMMO-SD-1 — Requirements Driven DesignDry runs verify that generated release output matches intended requirements before publication.
Recommendation — Validate release outputs against defined requirements before allowing live publication.

Practitioner Guidance

What to verify: Confirm that the dry run exercises the same generation inputs, templates, and validation logic as the live release, while the live path alone is responsible for pull request creation, approvals, and publication. If those diverge, treat the dry run as incomplete rather than reassuring.

Decision rule: Use dry runs for correctness and blast-radius inspection; use live releases only when you are satisfied that the repository output, review workflow, and approval gates all match the intended change. If a dry run surfaces ambiguity, do not “test it for real” in production.

Practitioner takeaway: The safest release process is the one where the dry run proves the content and the live release proves the control path, not the other way around.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Reviewed and updated by the NHIMG editorial team on October 30, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org