How to Prove You Shipped a Feature Before a Competitor
Your competitor’s launch post goes live on a Tuesday morning. Screenshots, a pricing page, a demo video — and the feature is yours. You built it fourteen months ago. You have the commit history to prove it, sitting in a private GitHub repository.
What you don’t have is a way to make anyone believe that commit history wasn’t edited last week.
That gap — between having evidence and being able to prove it — is what this article is about. Not in the abstract, but for the specific people who get hit hardest by it: founders, agencies, freelancers, and the compliance teams who have to defend them afterward.
The Founder Who Needed Proof: A Real-World Scenario
Picture a seed-stage founder we’ll call Mara. Her team spent a year building a workflow automation layer for a niche vertical. Then a better-funded competitor announced a product with the same core concept, raised a Series A on the back of it, and a reporter asked Mara for comment.
Her position in the conversation depended entirely on one question: can you prove you had this first?
Mara had Git history. She also had:
- A repository on GitHub, controlled by an organization whose settings any admin can change.
- Commit dates that, in Git, are just metadata supplied by whoever made the commit. Force-push, rebase, or a rewritten history and the dates change with it.
- Screenshots, Slack threads, and a Notion doc — none of which survive a determined challenge in a legal setting.
In other words, she had a story, not evidence. Investor conversations stalled. The narrative shifted from “we were first” to “we think they copied us, but we can’t prove it.” That’s a credibility problem that compounds into a valuation problem.
The uncomfortable truth: an internal log is only as trustworthy as the person who controls the server it lives on. In a dispute, that’s you — which makes it worthless to the other side.
Cryptographic timestamping solves this specific problem. Not by making your logs prettier, but by anchoring a fingerprint of your code into a public, immutable ledger that nobody — including the vendor that stamped it — can rewrite. The rest of this article is the practical version for teams in Mara’s position.
Why Developers and Compliance Teams Need Cryptographic Proof
The people who get asked “can you prove it?” are rarely engineers. It’s a founder in a diligence call, an agency owner in a payment dispute, or a compliance lead preparing for an IP audit. Here’s what each of them runs into.
Internal Git logs are editable by design. Git is a distributed system built so history can be rewritten. That’s a feature for development and a liability for evidence. When an opposing counsel argues your repository timestamps are self-serving, they are not making a wild claim — they’re making the obvious one.
“We independently developed it” is the default defense. A competitor doesn’t need to have copied you to hurt you. They only need to say they didn’t, and without verifiable prior art, that assertion is as good as your denial of it.
Compliance teams need tamper-evident artifacts. An auditor or a court wants something they can check without trusting your infrastructure, your employees, or your vendor. That means a proof that reduces to public mathematics — a hash and a block height — rather than a database row.
Patent risk is asymmetric. A non-practicing entity can file broad claims on technologies that thousands of teams already run in production. If you can’t show the date you built it, the cost of defending yourself lands entirely on you.
If you want the conceptual grounding on why a hash proves existence and how prior art invalidates claims, the concept page and the problem statement cover it in depth. For the purposes of this article, the mechanism matters less than the workflow: something automatic, continuous, and independently verifiable.
That is precisely the gap a managed timestamping service fills.
Your Playbook: Proving Prior Art with Timestamp GIT
Here is the full checklist, in order. Notice how little of it involves engineering effort — that’s deliberate.
Step 1: Install the GitHub App on your repository
Install Timestamp GIT from the GitHub Marketplace and select the repositories to monitor. There is nothing to add to your codebase, no dependency, no CI config to write, and nothing to install on developer machines. Your team keeps committing exactly as they do today.
Permissions, so there are no surprises:
- Standard mode requires read-only access to the source repository — GitHub’s permission model doesn’t offer a “commit hash only” scope — plus write access to the target repository where proofs land.
- Proof artifacts are written to a dedicated timestamps branch, either in the same repository or in a separate shadow repository.
Step 2: Let nightly anchoring happen automatically
Once connected, the pipeline runs without you:
- The GitHub App detects new commits via webhooks.
- Commit hashes are queued in an in-memory key-value store for batching.
- A midnight cron worker groups all pending hashes, writes a manifest
.txtper repository, builds a Merkle tree, generates OpenTimestamps proofs against public OTS calendars, and anchors the Merkle root into the Bitcoin blockchain. - Manifest and
.otsreceipt files are pushed back to your timestamps branch.
Bitcoin confirmation typically takes around three hours, so the proofs for a given night appear a few hours after the batch is anchored. You don’t need to monitor this.
Step 3: Collect your receipts and verification badge
Every anchored day gives you an immutable .ots receipt file plus an embeddable badge for your README. The badge link points to a public verification view, so anyone evaluating your claim — an investor, a lawyer, a customer — can check it without an account.
Public repositories are covered by the free Open Source tier; private repositories run on the Pro Agency plan. You can also pull badge URLs and markdown snippets programmatically:
curl -s https://timestampgit.dev/api/badgeLink/your-org/your-repo
Step 4: Produce evidence for stakeholders
When someone actually asks for proof, don’t assemble a zip file of screenshots. Use the artifacts built for the purpose:
- Repository status page — proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, a calendar heatmap, and downloadable audit CSV plus PDF certificate.
- Cryptographic verification page — a step-by-step Merkle chain walkthrough per date, computed entirely in the browser. Nobody sees what you verify.
- PDF certificate — a per-date document you can attach to a legal or procurement thread.
# Full audit ledger as CSV
curl -s -o audit.csv https://timestampgit.dev/api/audit/your-org/your-repo
# PDF certificate for a specific anchored date
curl -s -o certificate.pdf https://timestampgit.dev/api/report/your-org/your-repo/2026-11-03
Private repositories append an encrypted HMAC to their status URLs, so only authorized viewers can query them.
For teams that can’t grant read access: Enterprise ZK mode
Some organizations — regulated industries, or anyone whose source repository access is itself audited — can’t hand read permission to a third party. In that mode, a GitHub Action runs inside your own infrastructure and pushes only the commit hash to the Timestamp GIT API. The service never has read access to the source repository, and you only grant write access to the target repository.
If you need to run the entire stack yourself, there is a Docker 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 instance is available at http://localhost:8080 after startup, and a setup wizard walks you through connecting your GitHub App on first launch. A time-limited demo license is available from the Docker license page.
What to Avoid When Proving Prior Art
The failure modes here are boring and expensive. Avoid all five.
- Don’t rely on internal logs, Slack screenshots, or document revision history. Every one of them is editable by someone on your side, which is exactly the objection you’ll face.
- Don’t attempt to hand-roll the protocol. Assembling hashes, submitting to calendar servers, and managing proof files manually is the hard way — error-prone, easy to do wrong, and not something you want to explain in a deposition.
- Don’t wait for the dispute to start. Prior art is only useful if it predates the claim. Timestamping begins the day you install the GitHub App and accrues value daily; retroactive stamping is impossible by construction.
- Don’t confuse a public repository with proof. Making code visible tells people what you built, not when you built it. Visibility and verifiable existence are different properties.
- Don’t rely on a single unbroken chain of trust in one vendor. Ask whether the proof can be verified without the vendor — with Timestamp GIT, the answer is yes, which is the point covered next.
How Timestamp GIT Fits Into Your Compliance Workflow
Compliance reviewers ask three questions about any evidence pipeline: what data leaves the environment, what documentation exists, and what happens if the vendor disappears. Here’s how this one answers them.
Zero-knowledge by architecture. Timestamp GIT never sees, copies, or stores your source code. It extracts commit hashes, batches them, and anchors a Merkle root derived from SHA-256. Your actual logic stays in your repository.
Documentation on demand. The audit ledger is downloadable as CSV, and per-date PDF certificates are generated for the days you need to cite. Status endpoints expose the anchor data in JSON so you can feed it into an internal risk register:
curl -s https://timestampgit.dev/api/statusLast/your-org/your-repo
curl -s https://timestampgit.dev/api/statusCount/your-org/your-repo
curl -s https://timestampgit.dev/api/statusSummary/your-org/your-repo
Vendor independence. The proof reduces to SHA-256 and Bitcoin block data — no proprietary format, no lock-in. Even if Timestamp GIT ceased to exist, the receipts remain verifiable offline against the Bitcoin blockchain.
Transparency you can publish. Embeddable badges put the verification link directly in your README, so the claim is checkable by anyone who lands on the repository rather than asserted in a private deck.
For teams comparing approaches, Patent vs Timestamp: The Cheapest Way to Protect Source Code IP walks through when a patent is the right instrument and when a cryptographic proof is. They solve different problems, and most teams need the cheaper one first.
FAQ
Is a Bitcoin timestamp legally admissible in court? Cryptographic timestamps anchored in the Bitcoin blockchain are increasingly recognized as tamper-evident evidence. Timestamp GIT provides court-ready proofs that can be verified independently, making them suitable for legal disputes over prior art.
Do I need to change my development workflow to use Timestamp GIT? No. Once you install the GitHub App, Timestamp GIT automatically timestamps every commit to your monitored repositories each night. There are no CLI tools or manual steps required.
Can I prove a feature existed if my repository is private? Absolutely. Timestamp GIT only processes commit hashes, never your source code. Private repositories are supported, and proofs are stored in a separate branch or shadow repository without exposing your code.
What if Timestamp GIT goes out of business? Your proofs are anchored in the Bitcoin blockchain and are vendor-independent. You can verify them offline using standard OpenTimestamps verification tools, ensuring long-term validity even if our service is discontinued.
Does this replace filing a patent? No. A timestamp proves you had the code on a date; it doesn’t grant exclusivity. What it does is establish prior art that can invalidate someone else’s broad claim — and it costs a fraction of a filing.
Prove It on the Day You Build It, Not the Day You’re Asked
Mara’s problem wasn’t that she lacked evidence. It was that her evidence required trusting her. Cryptographic anchoring removes that requirement: a commit hash, a Merkle root, a Bitcoin block, and a receipt anyone can check.
The setup cost is one GitHub App installation. The ongoing cost is zero developer effort, because the nightly anchoring runs whether or not anyone remembers it exists.
If you’re shipping anything you’d want to defend — a feature, a library, an entire product — start the clock now. Install the GitHub App on a repository today, confirm your first anchor tomorrow, and put the badge in your README. Two days from now, you’ll have something no competitor can retroactively erase.
Related posts
- Patent vs Timestamp: The Cheapest Way to Protect Source Code IP
- Timestamp GIT Alternatives for Code Timestamping: Compared
- Automate Git Commit Timestamping With a GitHub App