Off Grid Software
Buy now

witness

Prove what you did before you shipped.

Witness seals every Go test, benchmark, and fuzz run into a timestamped record, and an independent custodian holds the copy. When the auditor samples or counsel asks, you produce evidence instead of recollection.

  • Sealed before the dispute, not after
  • Held by someone other than you
  • Verifies without trusting us
  • Your source never leaves home
  • Go only, on purpose
RUNNING

WITNESS

33m27s elapsed 58,911 events

ENV darwin/arm64 · 10 cpus · 5 parallel

PROFILE FINAL · 2x test repeats · 84 packages · 4,941 test functions · 59 fuzz targets

BUDGET pkg cap 2h3m33s · test est 14m22s · fuzz budget 7m18s · bench budget 15m0s

Live activity

TOOLS

PASSED14/14

passed
100%
TESTS

PASSED65,720/65,720

passed
100%
BENCH

RUNNING89/124

github.com/yourcompany/yourcodebase BenchmarkHost
72%
FUZZ

WAITING0/59

waiting
0%
LEDGER

RUNNING1.5 MiB/10 MiB

file 10 · 4.1 MiB current · 98 MiB total
15%
COMPLETION

WAITING0/9

waiting for run completion
0%

MODEFINAL

TESTS65,720 OK

BENCH89/124

RECORDSEALED

Official run record being sealed and timestamped.

Continuous evidence

— inputs tested

— of continuous fuzzing

Awaiting live evidence.

Last sealed
—
Peachy since
—
packages
—
targets
—

What it tests

Peachfuzz sends millions of malformed, unexpected, and adversarial inputs through the code.

Why it matters

It uncovers crashes and security flaws that ordinary tests can miss before customers encounter them.

Runs continuously. Every figure above comes from tamper evident, replayable run records.

Evidence model

Run locally. Seal it. Let us hold a copy of the proof.

Most teams can show that tests passed. Fewer can show it to a third party years later.

  1. 01

    Run locally

    Tests, benchmarks, profiles, and fuzz runs execute where your code lives. Your source never leaves home.

    tests · fuzz · benchmarks · profiles

  2. 02

    Seal with Off Grid

    The run folds into a hash linked ledger, gets a timestamp from an authority that isn't us, and seals. We verify it and keep a copy.

    replay · verify · timestamp

  3. 03

    Recall from the vault

    Years later, an auditor, a buyer, or a court asks. You hand them a record instead of a recollection.

    3rd party copy · later proof

  • Engineers get the exact record.
  • Agents get proof instead of optimism.
  • Legal gets something that survives the meeting.

The problem

A green check is a claim. Not a record.

Enterprise security review tends to move past whether the code shipped and onto what ran before it did, and who besides you can vouch for the answer. Four specific problems stand between our tests pass and we can prove it. Witness exists because every team meets all four the first time someone asks.

  1. 01

    Records made after the question are worth less

    Anyone can produce a document once a dispute starts. Courts, auditors, and buyers discount it, because the one thing it cannot prove is that it existed before the trouble did.

    • When was this created?
    • Who has held it since?
    • Can anyone verify that?
  2. 02

    Self held evidence proves almost nothing

    CI retention is usually well run and usually accurate. What it cannot do is separate the record from the party who controls it, which is the same reason financial statements go to an outside firm.

    • Who besides you holds a copy?
    • Could an admin rewrite it?
    • Why should a stranger believe it?
  3. 03

    Reconstructing the past is the expensive part

    Audit prep and legal discovery turn into engineers rebuilding last year from CI scrollback, tickets, and screenshots. Companies spend millions producing records for a single case. Most of that is the price of not having kept them.

    • What ran a year ago?
    • Under which flags and budgets?
    • Where is the output today?
  4. 04

    A green checkmark carries no detail

    CI proves a job exited zero. It does not say which tools ran, at which versions, under which flags, or what was preserved. A second question about tool versions, flags, or retained output has to be answered from somewhere other than the badge.

    • Which gates actually ran?
    • What failed on the way?
    • What evidence survived?
Witness

Teams say

  • CI passed.
  • We have tests.
  • The ticket is closed.

Enterprise asks

  • Which tools ran?
  • Under which flags and budgets?
  • What failed, passed, and survived?
  • Who holds the proof?

Enterprise stakes

Contracts are won on evidence, not adjectives.

Enterprise customers buy trust, and trust gets reviewed. Every framework pushes the same question back onto engineering: prove the standards operated before the code shipped.

One run becomes a sealed evidence bundle.

  • human .md reports
  • machine .json reports
  • ledger + sidecars
  • profiles + fuzz evidence
  • timestamp receipts
  • Off Grid retained copy
  1. 01

    The buyer asks for proof

    Security review becomes evidence review: what ran, what failed, and what record existed before anyone asked.

  2. 02

    Witness captures the plan

    Profile, budgets, tools, versions, flags, and why each default exists. The recipe is part of the record.

  3. 03

    Witness preserves the work

    Tests, benchmarks, profiles, and fuzz output are retained with the result rather than discarded at the end of the job.

  4. 04

    Witness seals the record

    Hash linked events, manifests, attestation, timestamp receipts. Verifiable later, by anyone.

  5. 05

    People and machines both get proof

    Markdown for people. JSON for machines. Same facts.

  6. 06

    Off Grid holds the copy

    Your source and secrets stay home. We keep only the sealed result your agreement allows: the copy that still verifies when someone argues.

Honest scope

Witness proves what ran, what was preserved, and what still verifies. It does not certify your company, audit your controls, or promise perfect software. Nothing honest ever does.

Compliance map

Certifications rest on evidence someone else can check.

Certification work draws evidence from identity, cloud, source control, tickets, monitoring, vulnerability, endpoint, policy, and people systems. Witness helps with one technical slice: it produces a sealed record of Go quality gates while the work happens, so the compliance platform and reviewer can sample a real run instead of asking engineering to reconstruct one from CI scrollback.

Five rooms, one question: prove it. Each of them needs an artifact rather than an assurance.

  1. 01
    The request arrives

    A buyer, auditor, or assessor asks for SOC 2, ISO, FedRAMP, CMMC, or HIPAA evidence, with a deadline attached. Without a record, this is the point where engineering stops shipping and starts searching.

  2. 02
    Local execution

    Engineers run tests, race, shuffle, count, benchmarks, profiles, fuzz, and respected Go security tools where the source already lives.

  3. 03
    Sealed evidence

    Witness turns the run into human reports, machine JSON, ledgers, sidecars, hashes, artifacts, timestamps, failures, and profile proof.

  4. 04
    3rd party recall

    Off Grid holds a sealed copy outside your systems, so the buyer verifies the record themselves instead of trusting the company that produced it.

  5. 05
    Repeatable evidence

    The next review asks again. The same software-gate evidence can be sampled again without pretending it represents the rest of the control environment.

  • Enterprise buyers Security review before signing. Answer in an afternoon instead of a quarter.
  • Auditors Sampling your SOC 2 or ISO period. They sample a sealed record. No audit week scramble.
  • Insurers Pricing your cyber policy, or reviewing a claim. Diligence you can produce, not just assert.
  • Regulators After an incident, asking what you did beforehand. Produce records on demand instead of reconstructing them.
  • Your own counsel Discovery, once someone alleges negligence. A record sealed before the dispute, not after.
  • SOC 2 Type II

    How Witness helps
    Each relevant release leaves contemporaneous evidence of the Go tests, analyzers, benchmarks, profiles, fuzzing, policy, code revision, result, and failures that Witness actually observed.
    What it is
    A SOC 2 Type II examination evaluates the design and operating effectiveness of controls over a stated period. The service organization and auditor determine which controls and evidence are in scope.
    Reviewers get
    The auditor can sample sealed software-change, testing, and release records when those records support the customer's control description and audit procedure.
    Third party
    Off Grid holds the sealed run copy, so that particular record does not depend only on the customer's CI vendor, screenshots, or internal storage.
    Scope boundary
    Witness does not cover the complete control environment and does not prove access, HR, vendor, infrastructure-monitoring, incident, or policy controls operated.
  • ISO/IEC 27001

    How Witness helps
    Repeated release records can show that the customer's chosen Go testing and release process operated over time instead of being recreated for a certification or surveillance audit.
    What it is
    ISO/IEC 27001 certification evaluates an information security management system. Software testing and change evidence can support that system, but it is only one part of it.
    Reviewers get
    The certification body can inspect stable technical evidence when sampling the software-development processes the customer has placed in scope.
    Third party
    Off Grid supplies a third-party-held verification path for the relevant ledgers, reports, hashes, attestations, and timestamp receipts.
    Scope boundary
    A sealed run does not establish that the customer's ISMS conforms to ISO/IEC 27001 and Off Grid is not the certification body.
  • FedRAMP

    How Witness helps
    Release-bound records can support selected change-control and control-assessment procedures by preserving what Go quality gates ran and what they reported.
    What it is
    FedRAMP authorization and ongoing monitoring require a broad program of control assessment, vulnerability evidence, inventories, POA&Ms, change control, reporting, and agency review.
    Reviewers get
    A 3PAO or agency reviewer can use a sealed run as one assessment artifact when the system's control implementation and assessment plan call for it.
    Third party
    Off Grid can keep that specific result copy for later recall during assessment, significant-change review, or evidence refresh.
    Scope boundary
    Witness does not provide FedRAMP authorization or continuous monitoring as a whole, and release evidence does not replace scans, POA&Ms, inventories, assessments, or agency decisions.
  • CMMC

    How Witness helps
    A release record can become an assessment object for selected system-and-information-integrity or change practices when the customer's implementation actually uses those gates.
    What it is
    CMMC assessments examine specified safeguarding practices for federal contract information or controlled unclassified information at the required assessment level.
    Reviewers get
    The assessor can sample the mechanism and activity record, tie it to an exact code state, and verify that the retained artifact still matches itself.
    Third party
    Off Grid supplies an independently retained copy of that narrow technical record without needing the customer's source or CUI.
    Scope boundary
    Witness does not handle CUI, satisfy every CMMC practice, set assessment scope, or issue an assessment result.
  • HIPAA Security Rule evaluation

    How Witness helps
    A sealed run can support the technical evidence for an evaluation or technology-change review when the customer maps that run to its own policies and security measures.
    What it is
    The Security Rule requires covered entities and business associates to perform periodic technical and nontechnical evaluation. HHS does not recognize private HIPAA Security Rule certifications.
    Reviewers get
    The reviewer can inspect what technical work ran, when it ran, what failed or passed, and whether the record still agrees with its hashes and manifests.
    Third party
    Off Grid holds the source-free sealed record for later verification; the custody product is designed not to receive PHI, source, tests, secrets, or private customer data.
    Scope boundary
    Witness is not HIPAA certification, does not establish Security Rule compliance, and must not receive PHI.
  • SSDF and federal attestation

    How Witness helps
    Machine-readable and human-readable run records can be lower-level technical artifacts behind the producer's statement about testing and verification practices.
    What it is
    The software producer attests to secure development practices across the software lifecycle and remains responsible for tracing that statement to supporting artifacts.
    Reviewers get
    A federal reviewer can inspect the relevant artifact without relying only on a signature or a prose description of what ran.
    Third party
    Off Grid can hold the sealed copy for independent later verification without collecting the source, tests, secrets, or customer data behind it.
    Scope boundary
    Witness does not sign for the producer, cover every SSDF lifecycle practice, or turn one release record into proof of overall conformity.

Witness helps a company complete certification evidence work by making one software-engineering evidence stream contemporaneous, sealed, portable, and independently retained. The customer's control environment, GRC workflow, auditor, assessor, certification body, and authorizing authority keep their own jobs and decisions.

Who it is for

For whoever asks the awkward question after the meeting.

The buyer, the auditor, the insurer, the counsel, the incident reviewer. Witness exists for the person who says: show me.

One run leaves evidence you can hand over.

Success or failure, every run becomes a human report, machine JSON, a hash linked ledger, a timestamp receipt, and preserved proof.

Checks clean
14/14
Tests passed
65,720
Benchmarks passed
124
Fuzz passes
59
Ledger events
66,336
Sidecars verified
763/763
  • Human report

    What failed, what passed, what to do next.

    Markdown for reviewers: outcome, action items, repro command, retained outputs, ledger references.

    human_review.md
  • Machine JSON

    Typed facts for automation.

    Failure class, crasher hash, corpus counts, reproducer argv, grade, policy violations, remediation hints.

    machine_failures.json
  • Certificate

    The verdict, with its working shown.

    Grade, profile policy, tool table, SBOM hashes, sidecar checks, ledger-chain status.

    final_certificate.md/json
  • Ledger

    Every event carries the hash of the one before.

    Sequenced JSONL facts: run start, tests, packages, fuzzing, checks, profiles, seals, verification.

    ledger/ledger.jsonl
  • Timestamp

    The sealed chain gets a receipt.

    An RFC 3161 receipt from an authority that isn't us. The receipt fixes the time from outside the run, and it is checkable against the authority's own trust root.

    tsa.json + timestamp.tsr
  • Profile proof

    Performance evidence survives the run.

    CPU, memory, block, mutex, benchmarks, fuzz corpus, crashers, stdout, and stderr stay with the result.

    profile_proofs/*.prof
  • Security reviewers

    Inspect the run itself, tools, versions, flags, and preserved output, instead of a summary of it.

  • Audit and compliance owners

    Point SOC 2, ISO, CMMC, FedRAMP, or procurement evidence at a sealed record with hashes and timestamps.

  • Incident and legal teams

    Failure evidence, repro commands, retained output, and an independent chain to argue from later.

  • Engineering leaders

    See whether the quality recipe actually operated: race, shuffle, repeats, fuzzing, benchmarks, profiles, budgets.

The workflow

Seal every release. Recall it years later.

Your code runs on your machine. Witness writes the record. We keep the copy. The day it matters, nobody has to take your word for anything.

witness lifecycle

Command tape
  1. witness quiz
  2. witness test ./...
  3. witness midterm ./...
  4. witness final ./...
  5. witness mcat ./...
  6. witness verify witness_testimony/<run-id>_final/

Observed in /Users/d/code/fun

quiz / test / midterm

quiz / test / midterm

result: fail (auto_fail). Ledger, failures JSON, and human review are sealed.

final

final

66,336 ledger events. Tests, fuzz, profiles, manifests, anchors, and TSA receipt retained.

verify

verify

Chain, fold replay, completeness, and terminal event all verify.

  • Every profile writes a run folder under witness_testimony, profile named in the suffix.
  • Failed runs seal too: ledger, machine failures, and human review, instead of vanishing into CI scrollback.
  • Final runs retain tests, fuzz output, benchmarks, profiles, anchors, manifests, and timestamp receipts.
  • Verification replays the facts: chain, fold, completeness, sealed terminal event.

Generated files

artifacts/final_certificate.md

Human certificate

Reviewer-readable verdict: outcome, grade, policy, tool table, hashes, and verify status.

artifacts/final_certificate.json

Machine certificate

Typed form of the same verdict for automation, audit import, and later comparison.

artifacts/machine_attestation.json

Run attestation

The metrics bundle: checks, tests, benchmarks, fuzz passes, ledger events, and sidecar status.

artifacts/anchors/*.jsonl

Anchor ledger

Timestamp-ready records that bind retained files, hashes, and proof material to the run.

artifacts/retained_facts/*.jsonl

Retained facts

Sharded pass records and run facts that can be inspected without replaying CI memory.

checks/, benchmarks/, fuzz/

Raw tool output

Captured stdout, stderr, profiles, corpora, and crashers for the work the tool actually performed.

SHA256SUMS + index

Manifest

Digest map for the bundle, so missing or modified evidence is visible during verification.

timestamp.tsr + tsa.*

Timestamp receipt

Off Grid calls the TSA, records the time, and returns the receipt that proves when the bundle existed.

What it does

Your quality work, finally visible.

The tests, analysers, and benchmarks your team already runs are not visible to anyone outside the build. Witness runs Go's own machinery plus the analyzers serious teams respect, and records everything worth arguing about: tool, version, flags, diagnostics, outputs, and why each default exists.

Tool inputs

  • go test
  • race
  • shuffle
  • fuzz
  • benchmarks
  • profiles
  • govulncheck
  • staticcheck
  • nilaway
  • gosec
  • errcheck
  • deadcode
  • gocyclo
  • goconst
  • fieldalignment
Witness
typed ledger

facts / hashes / replay

Sealed outputs

  • hash linked ledger
  • machine JSON
  • human report
  • SHA256 manifests
  • RFC 3161 timestamp
  • Off Grid retained proof

Tool dossier

What the run actually used.

Catalogued from the Witness check registry: defaults, streams, issue signals, and why each tool belongs in the evidence bundle.

  • native engine

    go test

    Compiles the target closure, runs the tests, and records JSON output, stdout, stderr, timings, and the repro command.

  • runtime discipline

    race + shuffle

    Race exposes data hazards. Shuffle exposes order dependence. The exact flags and seeds are sealed, so a reviewer can rerun the same claim.

  • performance evidence

    benchmarks + profiles

    Benchmarks run as evidence phases. CPU, memory, block, and mutex profiles are retained where the profile asks for them.

  • input pressure

    fuzz

    Fuzz targets run under profile budgets. Corpora, crashers, failing inputs, and repro commands are retained, not summarized away.

  • structured analyzer

    staticcheck

    JSON output, so rule IDs, severities, and locations stay machine-readable in the sealed bundle.

  • reachable vulns

    govulncheck

    Symbol-level scanning against the Go vulnerability database. OSV records and call-stack evidence are preserved.

  • nil-flow analysis

    nilaway

    Uber's nilaway as a real finding source: analyzer diagnostics are issues; package-load failures are tool errors, honestly classified.

  • security scanner

    gosec

    JSON findings with rule ID, CWE, severity, confidence, and location. Defaults skip fixture, vendor, generated, and test-only noise.

  • error discipline

    errcheck

    Finds unchecked errors in authored source, ignoring generated and vendored code by default.

  • reachability

    deadcode

    The Go tools deadcode pass, including test executables, so test-only call paths count.

  • complexity budget

    gocyclo

    Flags authored code over cyclomatic 10, skipping vendor, fixtures, tests, and generated files.

  • literal drift

    goconst

    Catches repeated production literals. Diagnostics define truth, not exit codes.

  • layout evidence

    fieldalignment

    The Go fieldalignment analyzer with tests included, so layout waste has nowhere to hide.

  • Works hand in glove with Go

    It runs go test, then turns checks, benchmarks, profiles, and fuzz targets into one repeatable evidence habit.

  • Records typed facts

    Every fact lands in a hash linked ledger: sequenced, validated, canonical.

  • Binds evidence to the revision

    The record carries the Git commit and artifact hashes. The proof matches the exact code, not roughly the right week.

  • Folds facts into a verdict

    Grades are computed from ledger facts, and the computation is replayable.

  • Publishes sealed bundles

    One run, one bundle: ledger, manifests, attestation, receipts, reports, sidecars.

  • Ships as signed platform bundles

    Official builds ship a tool bundle per platform for Linux amd64 and arm64, macOS arm64, and Windows amd64, each with SHA256 sums and a signed attestation.

  • Built reproducibly

    Pinned versions, trimpath, VCS provenance, and CGO disabled, so the same source produces the same binary hash across rebuilds.

  • Creates 3rd party proof

    Off Grid retains the sealed copy: independent proof the record existed and verified.

Evidence doctrine

One command. One policy. On the record.

Pick the profile that matches the moment. It carries the tools, flags, budgets, and retention rules. The recipe becomes a matter of record, not memory.

Evidence doctrine

Designed for scrutiny, down to the flags and versions.

Every setting exists because the artifact has to hold up in front of an engineer, a compliance owner, and counsel. Those three read the same artifact for different reasons, so it has to answer all three without a translation layer.

  • Ledger is source of truth

    The append-only ledger owns the truth. Reports and certificates are projections of the ledger, and verification fails if a projection no longer matches it.

  • Typed evidence or it does not count

    Facts are structs, closed enums, and validated schemas. The verifier refuses through 274 typed error identities, each naming the specific check that failed.

  • Verify by replay

    Verification replays the facts and rejects broken chains, drift, and mismatched sidecars. It runs offline against the bundle contents, so no party to the dispute has to be trusted.

  • Success and failure are symmetric

    A failed run publishes evidence too: repro commands, preserved output, explicit disclosure.

  • 3rd party proof matters

    An independent copy can be checked by a party who was not involved in producing it.

  • Nothing fails on judgement

    The verifier, the timestamp, the ledger, and the manifest each fail on mismatch rather than on judgement.

  • Evidence must survive

    Crashes, disk pressure, and seal failures do not erase evidence. A reserved ledger region guarantees the terminal record lands.

Settings table

Witness profile settings
ProfileWhen to use itTiming policyWhy it differs
witness quizFast affected feedback while an engineer or agent is still working.Race-scaled package timeout floor 20 minutes; aggregate safety floor 40 minutes; no benchmark or fuzz surface.Race and shuffle are on, affected targeting is on, and the loop is short enough to run before a change grows stale.
witness test ./...Normal development confidence across the requested target set.Race-scaled package timeout floor 25 minutes; aggregate safety floor 60 minutes; short benchmark and fuzz budgets.Two test repeats, race, shuffle, benchmarks, and fuzzing expose flaky tests, order dependence, data races, and input-sensitive failures before they become customer problems.
witness midterm ./...Broader pre-merge confidence when the change deserves more than the daily loop.Race-scaled aggregate safety floor 90 minutes; test budget floor 50 minutes; benchmark and fuzz budgets deepen from test.Keeps the same evidence surfaces as test, then gives them more room to expose flaky, slow, or input-sensitive failures.
witness final ./...Release-grade forensic evidence before production, customer delivery, or audit review.Race-scaled package timeout floor 40 minutes; aggregate safety floor 150 minutes; test budget floor 60 minutes.Verbose evidence, two repeats, race, shuffle, CPU profiles, memory profiles, and sealed artifacts create the record you expect to defend later. If one repeat fails, the failure is recorded.
witness soak ./...Long endurance pressure for code paths where flakes, heat, time, or resource behaviour matter.Package timeout floor 30 minutes; aggregate safety floor 24 hours; minimum duration 1 hour; max parallelism capped at 4.Benchmarks and fuzzing stay on for sustained pressure while race and shuffle are off to keep endurance runs stable.
witness mcat ./...Maximum confidence endurance run when the review bar is highest.Inherits soak intent with race and shuffle on; aggregate safety floor 24 hours; minimum duration floor 1 hour.Combines endurance pressure with race and shuffle so the record shows more than a quick green pass.
witness debug ./...Verbose local diagnosis when the operator needs to understand a run, not create a customer-facing release record.Race-scaled package timeout floor 25 minutes; aggregate safety floor 50 minutes; no benchmark or fuzz surface.Keeps race and shuffle on, turns verbose output on, and avoids heavier evidence surfaces.
witness verify <run-dir>Replay a sealed bundle from the run directory, ledger directory, or ledger file.Runs when evidence is challenged, handed to a reviewer, or recalled from storage.The ledger is canonical. Verification rejects broken chains, drifted manifests, mismatched sidecars, and report projections that no longer match the facts.

Profile times are authored policy floors and safety bounds. Witness derives the concrete run from the selected profile, discovered workload, target set, machine characteristics, and effective parallelism, then records the actual timings in the sealed bundle.

Proof record

Open the proof. See the whole run.

Witness keeps the tool flags, trust posture, retained copy, certification ecosystem, and rollout path in one reviewable record.

Record details

sealed copy

Why trust Off Grid Software

You do not have to trust us for the evidence to hold.

Witness exists because we needed proof that BLINK was actually great, not merely green in a terminal. We built it for ourselves first, and the BLINK release record below is the one bundle we can show end to end.

  • Built for BLINK first

    It began as our own release standard. The current release seals its own evidence: 65,720 test passes, 59 fuzz targets, a 66,336 event ledger, verified at grade 100.

  • Makes existing discipline inspectable

    The tests, analysis, security checks, and benchmarks your team already runs stop being invisible. They become work a reviewer can examine instead of work you have to describe.

  • Independent retained copy

    A sealed copy lives outside your CI, your laptop, and your artifact store. Independent, when it counts.

  • Verification does not depend on us

    The bundle verifies offline. If an artifact changes, verification fails. We could vanish tomorrow and your proof would not.

  • Sealed before custody

    Witness seals the bundle where the work runs. Off Grid receives the finished proof and cannot turn custody into permission to rewrite it.

  • Timestamped before the argument

    RFC 3161 receipts, multiple authorities raced, trust roots embedded. The record is sealed before the argument starts.

  • Honest legal scope

    Witness records execution evidence, nothing more. Governing law, liability cap, and reliance limit travel inline with every sealed index.

  • Failure records count too

    We do not only stamp green runs. Failure records verify with the same discipline.

  • Custodian, not auditor

    An audit firm sells judgment. A custodian sells custody. We never grade your engineering. We hold the sealed record, prove it never changed, and let verification speak. The narrower promise is the one that survives cross examination.

Where it fits

The receipt nobody can rewrite unnoticed.

Keep everything you have. Witness does not certify companies or replace auditors. It gives everyone in the room something better to point at: a chain of custody for what ran, what was found, and what was sealed.

  • Keep CI for execution.
  • Keep Vanta, Drata, Secureframe, or other GRC tools for control management.
  • Keep scanners and analyzers for findings.
  • Keep auditors for certification.
  • Use Witness to prove what your gates actually did.
  • Use the retained copy for diligence, audits, and disputes.

Certification ecosystem

Keep the stack. Give it stronger evidence.

Witness helps the tools and professionals already carrying your certification. Each system keeps its job; Witness supplies the sealed software-run record they can map, sample, and review.

  • CI runs the work

    Keep GitHub Actions, Buildkite, GitLab, or the runner you trust. Witness wraps the relevant run and emits a portable record without replacing execution.

  • GRC organizes the program

    Vanta, Drata, and Secureframe collect evidence, map controls, assign owners, and manage the audit workflow. Witness gives that workflow a sealed run-and-release artifact.

  • Scanners make findings

    Keep the scanners and analyzers that find defects. Witness records which tool ran, against which code state, what it reported, and whether the sealed record still verifies.

  • Tickets show follow-through

    Keep Jira or GitHub Issues for ownership, remediation, exceptions, and incident follow-up. Witness is technical execution evidence, not the task-management history.

  • Auditors and assessors decide

    The qualified reviewer chooses procedures, samples evidence, tests controls, and reaches the conclusion. Witness helps the company answer those evidence requests; it never issues the result.

  • Off Grid supplies custody

    The source-free sealed copy can sit outside the systems under review and be recalled later. That independent custody is the narrow role Off Grid must deliver reliably.

Enterprise rollout

Adopt beside the systems your team already trusts.

Start where the review pressure is real. Prove value on one narrow path. Widen when it earns it.

  • Founder-led evidence pilot

    One Go service, one workflow, one audit requirement. Your first sealed bundles.

  • CI and local developer workflow

    Drop the binary into CI. Run quiz while developing, final on release, with the Git commit bound into the result.

  • 3rd party record retention

    Choose which sealed copies Off Grid retains. An independent trail for when the stakes are high.

  • GRC and portal exports

    Feed the sealed artifacts to Vanta, Drata, auditors, customers, and trust portals.

  • Policy expansion

    Widen from one workflow to release gates, waivers, exceptions, and retention rules.

  • One trust model at every tier

    Every tier seals and verifies the same way. Moving up changes how long Off Grid holds the locked copy, not the signing setup customers have to manage.

Buyer checklist

Questions worth asking any evidence tool.

Ask them of Witness too. Every answer below is checkable against a bundle you can run yourself.

  • Can a 3rd party verify the run without logging into your CI vendor?
  • Can an independent provider retain a sealed copy?
  • Does verification replay the facts and fail on drift?
  • Are failures, skips, and waivers explicit instead of hidden?
  • Are profiles, benchmarks, and retained binaries preserved as evidence?
  • When a run fails, do you get repro commands and preserved output?
  • Does it complement CI, scanners, and auditors instead of pretending to replace them?

When it matters

You do not need Witness when things go well.

You need it on the day someone asks what you did before you shipped. That day is usually scheduled by someone else.

  • SOC 2 readiness, ISO 27001, FedRAMP, or CMMC planning.
  • Enterprise security review asking for proof of testing.
  • Incident review where failed runs matter as much as green badges.
  • Government, defense, healthcare, or fintech procurement.
  • AI written code you cannot fully vouch for.
  • Anyone asking whether the evidence was changed after the fact.

Retention and custody

Custody is what makes a record checkable by someone else.

Companies do not audit their own books. The statements go to an outside firm because a record held only by the party being reviewed carries less weight, however accurate it is. Software evidence has the same problem, and custody is the fix: Witness seals the record on your machine, and Off Grid holds your locked copy as an independent custodian. Think escrow agent, notary, chain of custody. We do not own it, edit it, or grade it. We hold it, so you can produce proof when your customer, auditor, buyer, regulator, or court asks what happened.

  • Independent custody

    1 year on Bronze, 3 on Silver

    For the buyer, auditor, or security reviewer who has to check your record without taking your word for it.

    Your run is sealed on your own machine, and a locked copy sits with an independent custodian, ready the moment proof is asked for.

    Retained
    The sealed bundle: reports, manifests, ledgers, hashes, timestamps, and verification data. Never source. Never secrets.
    Reason
    A record held only by the company under review carries less weight. This one sits outside your systems and still belongs to you.
    Guardrail
    Once the window opens, the copy is locked. Nobody can quietly swap the file after the awkward question has already arrived.
  • Customer proof

    10 years on Gold

    For certification, procurement, and dispute work, where the question is not what you claim but what you can produce.

    You log in and retrieve the sealed record yourself, the same afternoon your customer, auditor, regulator, or counsel asks for it.

    Retained
    A custody trail of what arrived and when, which account owns it, which release produced it, and which hashes identify it.
    Reason
    Proof has to outlive the moment and the tool version. A 2026 bundle is read with the 2026 instrument that made it, never a later guess.
    Guardrail
    You retrieve the receipt and we do not rewrite the story. Custody proves what was recorded, not a fresh memory of the run.
  • Locked retention

    Set by your plan

    For teams that still need proof long after the build, the review, the incident, or the deal itself has moved on.

    Bronze covers your first audit year, Silver the certification cycle, Gold the long tail of procurement, regulation, and legal exposure.

    Retained
    Every tier holds the window printed on its plan card, and ten years on Gold is the longest window we will publish.
    Reason
    The value is not storage. It is an independent copy that nobody can quietly change, waiting for the day somebody finally asks.
    Guardrail
    Off Grid is the custodian and never the owner. The record is yours, and custody exists so that you are the one who produces it.

The vault, in plain terms

Witness creates the sealed record on your machine. Off Grid holds your locked copy so you can produce independent proof when a customer, auditor, buyer, regulator, or court asks.

  • Witness seals evidence on your machine.
  • Off Grid holds your locked copy.
  • Released Witness instruments are retained with their verifier material.
  • A bundle produced by Witness X is verified with Witness X.
  • Retention stops quiet deletion during the custody window.
  • You retrieve your own evidence after login.

The going rate

What proof already costs.

A price only means something next to the alternative. These are the figures companies already pay to be believed. Read them as invoices, then add the cost that never appears on one: the engineering weeks spent assembling the evidence behind each of them.

  • Weeks of it

    Senior engineering time, every cycle

    Evidence hunts, sample responses, and security questionnaires, taken off the roadmap and handed to someone who did not sign up for it. It never appears on the audit invoice and it is usually the largest line. Price it against your own salary bands.

    Your payroll, not a survey
  • Twice over

    Paid once to consultants, once to your own team

    Readiness consultants tell you which evidence to produce. Your engineers still have to go and produce it. The fee below buys the checklist, not the work.

    The line item nobody budgets
  • $60K to $100K

    SOC 2 Type II, year one

    Readiness, consultants, and the audit itself. Then $15K to $40K every year to keep the letter current.

    Linford & Company, SOC auditors (opens in new tab)
  • $900K

    FedRAMP authorization, on average

    That is the GAO's number, not ours. Staying authorized runs another $200K to $500K a year.

    U.S. GAO, report GAO-24-106591 (opens in new tab)
  • $1.8M

    Discovery, in one lawsuit

    The median a major company spends producing records for a single case. Most of it is lawyers reading.

    RAND Corporation (opens in new tab)
  • $2.2B

    Recordkeeping fines since 2021

    Charged to over 100 firms by US regulators for one failure: records they could not produce.

    SEC & CFTC enforcement (opens in new tab)
  • $10.2M

    The average US data breach

    Investigation, notification, litigation, and a year of explaining yourself.

    IBM Cost of a Data Breach 2025 (opens in new tab)
  • 1 in 3

    Vendors lose deals this way

    A missing certification stalls the contract, and the buyer rarely tells you that is why it went quiet.

    A-LIGN Compliance Benchmark (opens in new tab)

Hold those numbers. A full year of Witness on Bronze costs less than the annual upkeep on the SOC 2 letter alone, and a year at any tier costs less than one lawsuit's discovery. What you are buying is not compute. It is an independent copy of the proof, held somewhere you cannot quietly revise it, which is the part that stops being independent the moment you hold it yourself.

Pricing

Priced against the failure, not the test runner.

Every plan starts with a one-time thirty-day free trial and is billed monthly after that, buying the custody described above for a different length of time. Nothing is charged during the trial, and cancelling before day thirty costs you nothing. Three things then carry across all three tiers. Custody is rolling rather than prepaid, so the window holds while the subscription holds and cancelling in month three buys three months plus the export window rather than the full tier term. Your rate is locked from your start date for the whole of that window. And once the trial converts, all sales are final: there are no refunds, credits, or prorated cancellations, so cancelling stops the next charge rather than returning the current one.

Honest. Up front. Predictable.

What each tier is for
Tier and windowWho needs itWhy it is worth it
Bronze, 1 yearFunded teams heading into a first SOC 2 or ISO 27001 cycle.Covers the whole observation period, so the auditor samples a sealed record instead of a reconstruction.
Silver, 3 yearsCompliance-sensitive teams that live in the standards year round.Spans a full ISO certification cycle, including the surveillance audits in between.
Gold, 10 yearsFinance, healthcare, government, and defense programs.Holds the long record for procurement and regulators, with an expert who can take the stand.

Published list prices, the same for a funded startup as for the Fortune 100. No negotiated rate, no Contact Sales button.

Thirty days free on every tier, one trial per customer. Nothing is charged until the trial converts, and cancelling before then costs nothing.

Your rate is locked from your start date for the whole of your tier's window. A later list price rise applies to new subscriptions, not to yours.

  • Local

    $69 USD per month for the whole organization

    Works on Go only

    Teams that need a durable internal quality record and will hold every copy themselves.

    • The same Go quality profiles and sealed local bundles
    • Human reports, machine JSON, ledgers, manifests, hashes, and timestamps
    • Offline verification from the bundle contents
    • No public verification page and no copy retained by Off Grid
    • Standard documentation and bounded email support
  • Bronze

    $578 USD per month for the whole organization

    Works on Go only

    Teams heading into their first SOC 2 or ISO 27001 cycle that need an outside copy of the quality record.

    • The same sealed bundle and offline verification as Local
    • Sealed receipt bundles, hosted and retained by Off Grid for 1 year while paid and in good standing
    • Public verification page
    • Email support
  • Most teams

    Silver

    $3,150 USD per month for the whole organization

    Works on Go only

    Compliance-sensitive programs that require three years of custody and a staffed review path.

    • Everything in Bronze
    • Rolling custody up to 3 years, held for as long as the subscription runs, not prepaid
    • Audit-ready reports and compliance mappings
    • Priority support
  • Gold

    $7,000 USD per month for the whole organization

    Works on Go only

    Finance, healthcare, government, and defense programs.

    • Everything in Silver
    • Rolling custody up to 10 years, held for as long as the subscription runs, not prepaid
    • Founder-level expert testimony at the published hourly rate, to explain the evidence to your auditors, regulators, or a court
    • SLA, SSO, procurement and legal review support

FAQ

Hard questions. Direct answers.

Does Witness support every language and build system?

No. Today the commercial promise is intentionally narrow: Go. Witness is built around Go tests, benchmarks, profiles, fuzzing, and the surrounding release evidence. If you do not ship Go, it is not for you yet. There is no non Go path today, and no announced date for one.

Does Witness get us SOC 2, ISO 27001, FedRAMP, HIPAA, or CMMC?

No. Certifications come from a control environment, management discipline, and the relevant auditor, assessor, or certification body. Witness does something narrower and more valuable than a badge claim: it creates and retains sealed technical evidence showing what ran, what passed, what failed, what artifacts existed, which hashes identify them, and when the record was sealed. That evidence can support certification, recertification, procurement, incident review, and litigation, but it is not itself a certification.

Is Witness replacing CI, Vanta, Drata, Secureframe, auditors, or counsel?

No. CI still executes work. GRC platforms still manage controls, owners, tickets, policies, and audit workflows. Auditors still decide audit procedure. Counsel still decides legal posture. Witness creates the sealed technical record those people can rely on: machine-readable results, human-readable reports, ledgers, manifests, timestamps, and retained proof. It complements those systems by giving them evidence with custody instead of screenshots and after-the-fact summaries.

How does Witness fit into CI?

CI still owns execution. Witness wraps the relevant release, test, benchmark, profile, and fuzz work so the result becomes a sealed record tied to the code state and policy profile. The operational goal is simple: engineers keep their workflow, but the organization gets a record that survives procurement, audit, and dispute review.

Does Witness slow our build down?

Not the loop your engineers live in. The quiz and test profiles are the developer path and add sealing overhead measured in seconds on top of the test time you already pay. The heavy profiles are release grade and meant to be scheduled rather than sitting in front of a merge: final for a release candidate, soak and mcat for endurance work you run out of band. One clarification worth making, because the numbers invite it: the timing floors published in the profile guide are safety ceilings that stop a runaway run, not expected durations. A 24 hour aggregate floor describes the outer bound before a run is abandoned, not how long a run takes. Witness runs go test as the engine, so the underlying test time is whatever it already is; what Witness adds is the recording, and the recording is cheap.

What is inside a passing Witness record?

A passing record is not just a green badge. It includes a human-readable report, machine-readable certificate, hash-linked ledger, manifests, timestamp receipt, run attestation, profile and policy facts, checksums, and verifier material. The purpose is reviewability: humans can understand the run, machines can compare the run, and verifiers can check whether the record still matches itself.

What does the ledger actually do?

The ledger is the ordered source of truth for the run. Events are sequenced, hash-linked, and replayed during verification. Reports and certificates are projections from that record. That matters because a polished PDF is easy to produce after the fact; a consistent ledger, manifest, timestamp, and verifier path is much harder to fake without leaving a mismatch.

Why preserve failed runs?

Because failures are often the most important evidence. A failure can show the gate operated, the defect was caught, repro material existed, and the release did not pretend everything was fine. Witness treats failures as first-class records: reason codes, machine failure JSON, human review material, repro commands, retained output, crashers where relevant, and the same sealing discipline as a passing run.

What is the difference between a certificate and a guarantee?

A certificate states what ran, what verified, and what evidence was preserved. A guarantee promises an outcome. Witness does the first, not the second. The distinction matters in review because a certificate can be checked against the bundle, and a guarantee cannot.

Does Witness tell us whether our tests are any good?

No, and saying so plainly is part of the product. Witness executes the tests you wrote and seals what happened. It forms no opinion on whether those tests were worth running. A suite built to go green proves that it went green and nothing further. Tests earn their keep through the failures they were designed to cause: the assertion that would have caught the regression, the input nobody sanitised, the boundary the code was never asked about. A wall of tests that cannot fail is worse than no tests at all, because an absence is honest and everyone can see it, while a false green is a claim your team will plan around. Sealing one does not improve it; it makes a weak claim permanent and checkable, which is not the same as making it true. Writing tests that genuinely try to break your code stays your job, and it is the job that decides what a Witness record is worth.

What can Off Grid prove, and what can it not prove?

We can help prove that a sealed Witness record existed, belonged to your account, matched its hashes and manifests, and verified according to the verifier material in the bundle. We cannot prove your tests were complete, your controls were perfectly designed, your software had no defects, or your company was legally non-negligent. Witness proves the record. It does not turn engineering judgment, audit judgment, or legal judgment into a magic certificate.

Is Off Grid an audit firm for software?

No, and the distinction matters. An audit firm examines your work and issues an opinion. Off Grid holds evidence and never grades it. The closer comparisons are an escrow agent, a notary, or chain of custody in forensics: we can attest what arrived, when it arrived, and that it has not changed since, while offering no view on whether your engineering was good. That is a narrower promise than certification, and it is the one we can keep under cross examination. Custody solves the same structural problem an outside audit firm solves, without pretending to be an opinion.

What exactly is Off Grid holding, and can you access it?

A customer-owned copy of the sealed Witness evidence bundle. Witness creates the record on your machine. Off Grid holds the locked copy as custodian so you can retrieve it later. We do not own the evidence, edit it, train on it, sell it, or treat it as our operational data. The point is independent custody: when your customer asks for proof, the answer is not limited to your own CI records or your memory of the run. On access: the evidence is yours, we do not own it, edit it, sell it, mine it, or use it to train systems, and the contract says so. There are three circumstances in which anyone here would open your bundle: you ask us to during a support request, a court orders it, or the law compels it. Where we are permitted to tell you, we will. The commercial promise is custody, not inspection.

Does Off Grid hold a key that could forge or rewrite our evidence?

No. The trust model is built around custody, not editorial control. Witness produces the sealed record where your work runs. Verification depends on the bundle, hashes, manifests, timestamps, and verifier material already sealed into it. Off Grid keeps the locked copy; custody does not grant a capability to invent a better history. If the retained record is changed, verification fails.

Can Off Grid read our source code, secrets, or customer data?

No. Witness runs where your code lives. We do not want your source code, secrets, customer databases, or production data, and the custody product is not designed around receiving them. The retained evidence is about the run and its proof material: reports, ledgers, manifests, hashes, timestamps, and verification facts.

Does verification require trusting Off Grid's website?

No. The retained copy is useful because it is independently held, but the evidence model cannot depend on our website being available or trustworthy. A sealed bundle is meant to verify from its own contents: ledger, manifests, hashes, timestamps, and verifier material. The website helps you find and retrieve what we hold for you; it is not the source of truth.

Why should our customer trust Off Grid as the 3rd party?

They should not have to trust our marketing. The bundle is designed to verify: hash-linked ledger events, manifests, timestamps, reports, machine attestations, sidecars, and replay material. Off Grid adds independent custody. Your customer can ask whether the record existed before the dispute, whether it verifies, and whether the copy was held somewhere you could not quietly rewrite. The claim your customer checks is the bundle, not our role in holding it.

Why does 3rd party retention matter if we already keep CI logs?

Because CI logs are still your records, inside your systems, subject to your retention, access, rebuilds, migrations, and admin privileges. That is the same structural problem financial reporting solved by requiring an outside firm, and it is why a reviewer can discount an internal record without disputing its accuracy. A retained third party copy changes the posture: the proof exists outside the system being reviewed, held by someone who does not benefit from the answer, and it verifies on its own contents rather than on anyone's word.

Will a bundle we sealed in 2026 still verify in 2036?

No, and we do not market that promise. Witness releases are immutable instruments. A result produced by Witness 2026 is a statement under the Witness 2026 rules, tools, threat model, evidence format, verifier, and consulted data. Each released Witness instrument is retained with its binaries, evidence format specification, verifier, data snapshots, checksums, commit identity, build metadata, tool metadata, release notes, assumptions, and limits. It is independently timestamped, so a historic result stays verifiable under the exact rules, tools, and threat data that produced it. The clean promise is not 'latest Witness reinterprets everything forever.' The clean promise is: a bundle produced by Witness X is verified with Witness X. Use the Witness instrument that produced the bundle unless a later release explicitly says it supports that older format. Do not use Witness 2036 to reinterpret a 2026 result by accident, because the 2026 result is a statement under the 2026 instrument. That is easier to explain in court or an audit than a claim that a current release reinterprets every past format: the old release is preserved as an artifact with its assumptions and verifier, while current Witness stays free to represent today's rules, tools, and threat model.

What happens when a newer Witness finds issues an older Witness did not?

That is responsible change, not a contradiction. Your 2026 bundle proves what Witness observed in 2026. New Witness may observe new issues on the same code because the tool, rules, threat model, or threat data improved. The threat landscape evolves daily, and no tool can predict future flaws, future exploit paths, or future reviewer expectations, including this one. When you remediate and seal a new passing result, the delta is itself evidence of responsible change: historical state, new detection, remediation, renewed attestation.

Does Witness prove we were not negligent?

No. Negligence is a legal conclusion. Witness helps establish contemporaneous technical facts: what ran, what failed, what passed, what was preserved, what policy was in force, and when the record sealed. Counsel can use those facts. An auditor can sample those facts. A buyer can review those facts. Witness does not replace the judgment of any of them.

How does this help if we get sued?

Negligence turns on standard of care, and standard of care is argued from contemporaneous records. One common line of attack is not that the tests were weak but that the evidence was assembled after the complaint landed. A hash linked ledger, a timestamp from an authority that is not us, and a copy held by an independent custodian answer that attack directly: the record existed in this exact form before the dispute, and it still verifies. Sealing every release also makes these ordinary course records rather than litigation artifacts. Witness cannot win a lawsuit or make negligence go away, and no evidence system can. It can spare your counsel the alternative, which is engineers rebuilding last year from CI logs, Slack threads, and memory while the meter runs.

Does sealed evidence ever work against us?

Yes, and we would rather say so here than have you discover it later. Failed runs seal with the same discipline as passing ones, so a record showing a gate failed before a release is discoverable too. We consider that a feature. A record that only ever contains passing runs is easier to challenge, because the absence of failures is itself a question. The teams this serves are the teams that act on failures: for them the full record shows a gate caught a defect and the process worked, which is a far stronger story than a year of unbroken green nobody can verify.

Can someone subpoena Off Grid directly for our evidence?

They can try, and you should assume that anyone determined enough will. Here is what we commit to when it happens. We notify you before producing anything, unless a court order legally forbids us from telling you. You get a reasonable window to move to quash before we respond. Where a protective order is available, we will seek one. We are the custodian of your record, not a party with an interest in disclosing it, and we will not treat a request as routine simply because complying is easier than resisting. Two things are worth being clear about. We cannot promise to defeat valid legal process, because no custodian can, and a commitment to fight every request regardless of merit would be a promise we could not keep. And what we hold is the sealed evidence bundle, which contains reports, ledgers, manifests, hashes, timestamps, and verification material. It contains no source code, no secrets, and no customer data, so the material reachable through us is narrower than what sits in your own systems.

Does having a custodian create a discovery target we did not have before?

It creates a second holder of a record you already had, which is a fair thing to weigh, so here is the honest arithmetic. The evidence itself was always discoverable from you, because it describes your own release process and lives in your own systems first. Custody does not create new discoverable content; it creates another place the same content exists, held by someone with no stake in the outcome. In practice that usually helps rather than hurts, because the version we hold is the one nobody can be accused of having curated, and its existence before the dispute is exactly the fact that is hardest to establish after one starts. The tradeoff worth naming plainly: once you routinely seal evidence, allowing custody to lapse during a live dispute is itself an act a court can look at. That is an argument for keeping custody current when it matters, and it is a reason to think about this before you are in a dispute rather than during one. If your counsel wants to review the custody terms before you subscribe, we would rather they did.

Where is our evidence stored, and under whose law?

Off Grid Software operates from Ontario, Canada, and Ontario law governs the customer agreement. Retained evidence starts in Google Cloud's northamerica-northeast1 region, which is Montreal, Quebec. That is where it starts, not a commitment to where it stays. We can and will move it, and add regions alongside it, wherever redundancy and resilience need us to, and we will do that without asking first. A custodian whose evidence sits in exactly one place is a custodian with one way to lose it, so treat any single region as a starting position rather than a guarantee. If a specific residency is a hard requirement for your program rather than a preference, do not rely on our default: self-hosted deployment puts the location under your control and your audit scope instead of ours. It is licensed and priced separately, and it is a different trade rather than a cheaper one, because we hold nothing and therefore cannot vouch for custody of anything. Two further implications worth stating rather than leaving you to work out. We offer this service to businesses in Canada and the United States, and we do not market or sell it into the European Economic Area, the United Kingdom, or Switzerland. Do not send us personal data of individuals located in those territories: that needs a signed addendum, we do not offer one by default, and we make no representation that this service satisfies the GDPR or the UK GDPR. For customers who care about the CLOUD Act, the honest position is that the data sits in Canada under Canadian law while the storage provider is a United States headquartered company, and that distinction matters to some legal teams and not others. If your program requires evidence to sit somewhere specific, self-hosted deployment is available under a separate licence.

Why are timestamps and retention windows part of the product instead of an implementation detail?

Timing is often the whole dispute. A record that appears after the customer asks, after the auditor samples, or after the lawsuit starts is a weaker record. Witness is designed to show the evidence existed when the work happened, then Off Grid custody keeps extending the locked-copy expiry for as long as the account is paid and in good standing. Read the retention windows on the plan cards as rolling, not prepaid. Your tier sets how far back custody reaches at any moment, and it holds while the subscription runs. Buying Gold and cancelling in month three does not buy ten years of storage; it buys custody for those three months plus the wind-down window to export what we hold.

Why is pricing tied to retention instead of test volume?

Because the expensive part is not running a test binary. The expensive part is credible proof when a buyer, auditor, regulator, or court asks for it. Bronze protects the first audit year. Silver protects the certification cycle. Gold protects the long record. We price against the cost of not having independent evidence, not against CPU minutes.

Storage is cheap. Why not hold our evidence for X years, and why does a lapsed payment end custody at all?

It is a reasonable question, and you are right that the storage itself is inexpensive. The cost sits somewhere else. What custody buys is our commitment to stand behind a record: to hold it under a locked retention window, to keep it in a state where it verifies, to account for how it was stored if a court asks, and where your plan includes it, to write a custodian's declaration describing how we received and held it. Each of those is an obligation rather than a file, and obligations accrue for as long as we hold the record. A custodian holding evidence indefinitely for accounts that have lapsed takes on commitments it has no way to honour properly, and we would rather offer a window we can genuinely stand behind than a longer one we cannot. That is also why the tiers are priced the way they are. Gold costs more than Bronze because ten years of responsibility is a larger commitment than one year, not because ten years of disk costs more. And it is why a lapsed account gets a wind-down period rather than immediate deletion: the record belongs to you, so the right thing is to give you time to take it with you.

Can the price go up on us?

Not during your guaranteed term. The rate you start at is locked from your start date for the full length of your tier's window: one year on Bronze, three years on Silver, ten years on Gold. Your start date is the day your thirty-day free trial begins, not the day it converts, so taking the trial does not shorten the window or move you onto a later price. A company starting Gold today holds that monthly figure until the same date in 2036. If we raise list prices next year, the new figure applies to new subscriptions and to anyone returning after a lapse, never to a term already running. The reasoning is straightforward. Custody is only useful if you can rely on it for the whole window, and a vendor able to reprice a dependency at will has not offered custody so much as storage with leverage attached. Two boundaries worth stating plainly. The guarantee follows continuous payment, so an account that lapses and later resubscribes starts again at the list price current at that time. And the guarantee covers your term rather than forever: when a ten year Gold term ends, renewal is priced at whatever is current then, with the same guarantee running from that date.

What happens to older evidence if we downgrade a tier?

Your window shrinks to the new tier's, and anything outside it leaves custody. Moving from Gold to Silver takes your reach from ten years to three, so bundles older than three years fall out of the retained set. We do not delete them the moment the change takes effect; you get an export window to retrieve anything the new tier no longer covers, the same courtesy an account closure gets. Two things follow from that. Downgrading is not a way to shed cost while keeping the long tail, and if the old records are the ones that matter for a specific audit or dispute, export them before you change tiers rather than after. The bundles you export keep verifying offline regardless, because verification never depended on us holding them.

What happens if we stop paying?

Custody is a paid service, not a free warehouse after the lease ends, and the runway is longer than most people expect. The day a payment fails nothing changes and our processor retries. About a week later, once those retries are done, Witness goes read-only: it stops accepting new runs and keeps verifying everything you already sealed. Around thirty days in you get a second notice saying your data is scheduled for deletion in about sixty more days and that you should export now. On the third missed invoice the account is treated as closed and deletion follows once the storage expiry passes. You can clear the balance yourself at any point before deletion by signing in and paying; there is no reactivation fee and no ticket to raise. The part worth knowing: that read-only ability never expires. What you already produced stays readable and verifiable whether or not you subscribe again, because what you made is yours.

Do you offer refunds, credits, or a trial?

There is a trial. There are no refunds. Every tier, Bronze through Gold, starts with a one-time thirty-day free trial of the full service: real custody, real sealing, real verification, not a reduced demo. We take a payment method up front so the subscription converts without a gap, and nothing is charged during those thirty days. Cancel before day thirty and you are not billed at all, which is the window in which to decide whether custody from us is something your organisation wants. Once the trial converts, all sales are final: there are no refunds, credits, or prorated cancellations. Cancelling stops the next month rather than returning the current one, and the custody window you have already paid for is honoured in full, including the export period. We would rather state that plainly here than have you discover it after a charge. The reason we can be this firm is that we try to leave nothing for you to find out later: the trial, the tiers, the retention windows, the rate lock, the wind-down process, the jurisdiction, and what happens to your evidence if you stop paying are all written on this page before you spend anything. If a term here does not work for your organisation, the right time to tell us is during the trial rather than after the first invoice.

How does this help sales and procurement?

Security questionnaires increasingly ask for artifacts rather than attestations. Witness gives you a concrete answer: here is the sealed record, here is the retained third-party copy, here are the hashes and timestamps, here is what passed and failed, and here is the verification path. That shortens the distance between 'send us proof' and 'here is the proof.'

Who else is using this? Can we talk to a reference?

Not yet, and we are not going to dress that up. Witness has been used on real Go codebases outside our own, but the custody service is new and we are not currently holding retained evidence for any customer. There are no reference calls to arrange and no logos to show you. Saying otherwise would be the exact behaviour this page argues against, since a page insisting that self attestation is weak has no business offering nothing but self attestation. What we can offer instead is the thing a reference call is a proxy for. Every claim on this page is checkable without talking to anyone: run Witness against your own repository, seal a bundle, verify it offline, and try to alter it and watch verification fail. Our own BLINK release record is the one bundle we can show end to end, and we know it is our own homework. If being an early custody customer is not a risk your organisation takes, that is a reasonable position, and the honest advice is to wait until we can point you at someone other than ourselves.

Off Grid looks small. Why is that safe?

It is a fair question and the honest answer is that Off Grid is deliberately small, which is exactly why the trust model does not rest on our size. Most vendors ask you to trust their headcount, their certifications, and their balance sheet. We ask you to trust a hash chain, a third party timestamp, and offline verification, none of which improve if we hire fifty people. The evidence verifies without us, and the bundle is exportable at any time. The one thing our size genuinely affects is service: support is direct rather than tiered, and the founder is the person who shows up for an expert testimony engagement. Judge that as you would any specialist firm. What our size cannot affect is whether your proof survives, and that is the part the architecture settles.

What happens to our evidence if Off Grid shuts down?

Your bundles keep verifying, and that is not a reassurance, it is the architecture. A sealed bundle verifies from its own contents: ledger, manifests, hashes, timestamp receipts, and verifier material. The timestamp comes from an authority that is not us. Nothing in the verification path calls an Off Grid server, so a bundle you hold verifies on a laptop with no network in a world where this company no longer exists. What you would lose is the independently held copy and the retrieval service, which is why the wind-down commitment matters: if we cease operating, the same export window applies as for any account closure, and you should keep your own copy of every bundle regardless. We designed the product so that depending on us is optional, and we would encourage you to put the same question to any custody vendor you evaluate.

What is Off Grid's own security posture?

The most useful answer is what the vault does not contain. We never receive source code, secrets, credentials, customer databases, production data, or PHI, because Witness runs where your code lives and seals only the evidence: reports, ledgers, manifests, hashes, timestamps, and verification material. That narrows the blast radius of any incident on our side to material that is, by design, meant to be handed to auditors and adversaries anyway. Retained copies are encrypted at rest, custody is locked for the retention window so stored bundles are not casually replaceable, and any tampering with a retained copy causes verification to fail rather than passing silently. Off Grid does not hold SOC 2 or ISO 27001 certification today, and we would rather state that plainly than let it come up later in your vendor review. Those certifications are meaningful, and we understand the teams buying this product often hold them. What we offer alongside that gap is a custody model you can verify directly rather than take on trust. If your vendor review requires a certified subprocessor, please raise it early and we will tell you honestly whether we can meet the requirement.

Why do purchases go through Stripe?

Because payment collection is not the place to improvise. Checkout, cards, receipts, tax handling, and payment security belong on Stripe's platform. Our server still owns product identity, plan rules, and prices, so the browser cannot invent a cheaper plan. Stripe collects payment; Off Grid grants the entitlement that matches the server-side product.

witness

The record has to exist before anyone asks.

That is the one thing no vendor can backfill for you. One service, one workflow, your first sealed bundles, and a walkthrough scoped for your security, compliance, and legal reviewers in one session.

Book your evidence pilot (opens in new tab)