Timestamp GIT

← All posts

2026-11-18

Prove Prior Art Before You File: A Founder's Guide

Prove Prior Art Before You File: A Founder's Guide
timestamp git blockchain proof

Prove Prior Art Before You File: A Founder’s Guide

You are three weeks away from a provisional patent filing. Your attorney sends over a checklist: invention disclosure, inventor assignments, and a question that stops you cold — “Can you show me evidence this existed before the filing date?”

You open GitHub. There it is: eighteen months of commits, a working prototype, a private repository with 4,000 commits. Surely that’s proof.

It isn’t. Not the kind that survives a challenge. Your Git history lives on a server you don’t control, in a database that can be rewritten, on a timeline that nobody outside your company has any reason to trust. For a founder about to spend five figures on a patent, that gap matters more than most people realize until it’s too late.

This guide is for founders, CTOs, and the compliance people who end up cleaning up after them. It covers what prior art actually is, why your commit log is weaker evidence than you think, and a practical playbook for getting cryptographic, court-ready proof of existence before you file — without adding a single step to your developers’ workflow.

Why Prior Art Matters for Founders (and Why Git Logs Aren’t Enough)

Prior art is any evidence that your invention was known before a given date. It cuts both ways: it can strengthen your own filing, and it can be used to invalidate someone else’s patent that never should have been granted.

Three scenarios make this concrete for a founder:

  • Patent trolls. Non-practicing entities file broad patents on things developers have been building for years. If you shipped that logic months before their filing date but can’t prove it, you’re negotiating from a position of weakness. Cryptographic prior art is the shield that turns their claim into a pile of invalidated paperwork.
  • Employee and contractor disputes. When a lead developer leaves — or a contractor’s invoice goes unpaid — the question becomes when a specific feature was conceived. Without an immutable timestamp, it’s a he-said-she-said fight.
  • The “clean room” defense. A competitor claims they independently developed the same feature. Proof that you had finished logic 18 months earlier creates a wall they cannot climb.

Standard Git history fails all three tests. Commits are stored on infrastructure you rent, not own. Commit dates are trivially editable with git commit --date. And in a legal audit, internal logs are frequently dismissed as self-serving or manipulatable by exactly the party presenting them.

Cryptographic prior art fixes the trust problem, not the data problem. Timestamp GIT does this by collecting your commit hashes, building a Merkle tree over them, and anchoring the Merkle root into the Bitcoin blockchain through the OpenTimestamps protocol. The result is a timestamp nobody can alter or forge — not you, not GitHub, not the vendor.

For a deeper treatment of the troll problem, see Cryptographic Prior Art: The Startup Shield Against Patent Trolls. If you want the forensic details of why raw Git timestamps fall short in legal review, Do Git Commit Timestamps Hold Up as Proof? covers that ground.

Your Prior Art Playbook: From Commit to Court-Ready Proof

Here’s the sequence a founder should run before the filing conversation, ideally starting the day the first prototype commit lands.

Step 1 — Install the GitHub App on the repository

Install the Timestamp GIT GitHub App on the repository that holds the invention. In Standard Mode, the app reads the HEAD commit hash of your monitored repository automatically.

One practical detail worth knowing up front about the permission model: the GitHub permission system does not offer hash-only access, so the app needs at least read-only access to the source repo, plus read-write access to a target repo where proofs are written. That target can be the same repository or a separate shadow repository — your choice. Proofs land in a dedicated timestamps branch, so nothing touches your mainline code.

If you’re a solo founder, the Open Source plan covers public repositories for free. Private repositories need a paid tier, which is why most founders do this at the point the code stops being public.

Step 2 — Let the nightly job do the anchoring

Nothing to schedule, nothing to run. Once the app is connected, the pipeline handles itself:

  1. Commit detection via webhooks as you push.
  2. Hash queue — commit hashes sit in an in-memory key-value store, waiting for the batch.
  3. Midnight cron worker groups every pending hash, writes per-repo manifest .txt files, builds a Merkle tree natively, creates OpenTimestamps proofs against public OTS calendars, and anchors the Merkle root into Bitcoin.
  4. Proof delivery pushes the manifest and .ots receipt files back to your timestamps branch.

Confirmations take a few hours — typically around three — so the proofs appear in your repo the next morning. Your developers never learn that any of this exists, which is the entire point: the moment prior-art protection requires a habit, it stops happening.

Step 3 — Collect the artifacts your lawyer actually wants

Once the batch confirms, you have a paper trail that exists outside your infrastructure:

  • The .ots receipt file — an immutable proof binding your manifest hash to a specific Bitcoin block.
  • The manifest .txt — the list of commit hashes stamped that day.
  • A PDF certificate per date, downloadable from the repository status page.
  • An audit CSV ledger covering the full history, for compliance review.
  • A verification badge you can embed in your README, so the proof is publicly visible.

Your public status dashboard at /status/{user}/{repo} shows proof longevity, earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind each stamp. That’s the page you hand to counsel, along with the certificate.

If you want to check a specific day yourself, the cryptographic verification page walks the Merkle chain step by step and computes everything locally in your browser — the same zero-knowledge property as the anchoring side.

Step 4 — Know when to switch to Enterprise ZK Mode

Most founders will never need this. But if your repository contains trade secrets so sensitive that even the commit hash is too much metadata to hand to a vendor, Enterprise ZK Mode changes the shape of the integration: a 12-line GitHub Action runs on your own infrastructure and pushes only the commit hash to the Timestamp GIT API. Your source code never leaves your environment, and the service never needs read access to the source repository — only write access to the target repo that receives proofs.

For everything in between, Standard Mode’s guarantee applies: the service never sees, copies, or stores your actual source code. It stamps a hash.

Step 5 — Self-host if you’re air-gapped

Some organizations — regulated industries, defense contractors, anyone with an internal-only network — can’t use a managed service at all. Timestamp GIT ships as a Docker image with a self-hosted license.

A quick-start Docker Compose setup looks like this:

services:
  timestampgit:
    image: rue1401/timestampgit:prod
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app/data
    restart: unless-stopped
  valkey:
    image: valkey/valkey:8
    restart: unless-stopped
docker compose pull
docker compose up -d
docker compose logs -f timestampgit

The app is available at http://localhost:8080 after startup, and a setup wizard on first launch walks you through connecting your GitHub App and configuring the instance. You’ll need a license file — a time-limited demo license is available by submitting the request form on the Docker License page with your name, company, email, and optional phone number.

What to Avoid When Proving Prior Art

Don’t rely on internal logs or email timestamps. They’re the first thing opposing counsel attacks, and they lack cryptographic integrity. A git log output with a comfortable date on it proves nothing about whether that date was real.

Don’t hand-roll the proof yourself. Doing the anchoring manually — the hard way, with command-line tooling and raw Bitcoin transactions — is error-prone, doesn’t scale past one developer, and produces artifacts that are easy to get subtly wrong. The whole point of the managed path is that a nightly job nobody has to remember is more reliable than a process someone has to remember.

Don’t wait until after filing. Prior art is only useful if it precedes the relevant date. Start anchoring as soon as you have a working prototype — not when your attorney asks.

Don’t assume a patent filing is the only thing that protects you. Prior art is defensively valuable even if you never file: it blocks others from patenting what you’ve already built, and it supports trade-secret claims by establishing a defensible timeline.

Don’t assume the registry is permanent just because it’s a vendor. Verify the independence claim before you commit. Timestamp GIT proofs rely only on SHA-256 and Bitcoin block data — no proprietary format, no lock-in — so verification does not depend on the company continuing to exist. Ask that question of any vendor in this space.

How Timestamp GIT Fits Your Compliance and Development Workflow

The reason this works as a founder’s tool rather than a legal-team science project is the division of labor.

  • Zero-knowledge by architecture. The service processes commit hashes, not code. Enterprise ZK Mode narrows that further to a hash pushed from your own CI.
  • No developer overhead. No CLI, no per-commit ritual, no install on developer machines. Push code; the batch runs at midnight.
  • Artifacts where reviewers expect them. Proofs live in your repository. Audit CSV and PDF certificates are downloadable. Badges are embeddable for public repos.
  • API access for your own tooling. The public status endpoints are straightforward to wire into an internal dashboard:
curl -s https://timestampgit.dev/api/statusSummary/acme/payments-core
curl -s https://timestampgit.dev/api/statusLast/acme/payments-core
curl -sO https://timestampgit.dev/api/audit/acme/payments-core

Private repositories append an encrypted HMAC to status URLs, so only authorized users can see their status — the HMAC is specific to the server instance.

  • Deployment flexibility. Managed GitHub App by default, Enterprise ZK for strict source control, Docker self-hosting for air-gapped environments.

For a broader comparison of the tooling landscape as it stands today, Best Tools to Timestamp Source Code for Auditors is the companion read.

FAQ

Can I use Timestamp GIT to prove prior art if I’m not filing a patent? Yes. Prior art is valuable for defensive publication — preventing others from patenting your work — and for protecting trade secrets. Timestamp GIT gives you cryptographic proof of existence that can be used in a range of legal contexts, whether or not a filing ever happens.

How long does it take to get a Bitcoin-anchored proof after I commit? The process is fully automated. Commits are batched nightly, and the Bitcoin transaction typically confirms within a few hours. You’ll receive the .ots receipt and manifest in your repository shortly after confirmation.

Is the proof generated by Timestamp GIT admissible in court? The proof relies on the OpenTimestamps protocol and the Bitcoin blockchain, which are globally recognized cryptographic standards. Admissibility depends on jurisdiction and how the evidence is presented, so treat the cryptographic proof as strong supporting evidence and have your attorney confirm the local rules. It is designed to be court-ready and independently verifiable.

What if I have multiple repositories or need to keep my source code completely private? Timestamp GIT offers Standard Mode (GitHub App) for most users, and Enterprise ZK Mode, where a GitHub Action pushes only commit hashes to the API — zero code access. Docker self-hosting is also available for air-gapped environments. Multiple repositories are supported across the pricing tiers: free for public repos, Pro Agency for private repos, and Enterprise ZK.

The Filing Deadline Is Not the Deadline That Matters

The date that decides your prior-art position is the one baked into a Bitcoin block, not the one on your calendar invite with counsel. Founders who figure this out early get an unfair advantage for free: install the GitHub App, push code as usual, and let the nightly batch build a cryptographic record that predates every conversation you’ll ever have about patents.

If you’re close to a filing, do it this week. Timestamp GIT takes a few minutes to connect and then runs invisibly — which is exactly what you want from infrastructure that might one day decide who owns your code.


Related posts

EU label: AI-generated content