Back to Blog
Five numbers that prove Git is not enough for database version control
October 30, 2026 12 min read Shayntech Engineering

Database Version Control: Why Git Isn't Enough for Your Data

Ask an engineering team how they version their database and the answer is almost always Git. Ask what the customers table looked like at 14:02 yesterday, and the same team goes quiet. Git solved version control for code and left the harder half of the problem untouched: the data itself.

That gap is easy to describe and hard to argue about, so this post measures it instead: five numbers you can collect this week, each one Git cannot move however disciplined the commit history.

Why the Comparison Breaks Down at the Row Level

Git rests on five primitives: commit, branch, diff, revert, blame. Each depends on one assumption - the thing being tracked is a text file that only changes when a person deliberately edits it. Production data breaks that assumption a thousand times an hour.

  • Commit: a deploy changes the migration file; the rows change because requests arrived. Nothing bundles the two into one reviewable moment.
  • Branch: a repository copies in a second. Copying a live database means provisioning storage, credentials and a restore window.
  • Diff: Git shows exactly which lines moved. Comparing production to yesterday means restoring yesterday first.
  • Revert: a revert puts the file back and nothing else has to happen. Reverting rows means undoing every write since the bad change.
  • Blame: attribution stops at the person who merged the file. It never reaches the script that touched 9,000 rows at 14:55.

That is not a criticism of Git, only evidence that it was aimed at a different object - one that costs money when it breaks.

The Five Numbers That Prove the Gap

Measure these five before you evaluate any product. Rough estimates are fine; direction matters more than the decimal place.

One: Restore Lead Time

How long does it take, end to end, to make yesterday at 14:02 queryable? For backup-based teams the honest answer is usually two to six hours: find the snapshot, provision a target, restore, replay logs, verify. A team with continuous capture answers in under a minute, because the state was already recorded and only has to be read.

Two: Recovery Point Gap

What sits between your last recoverable point and the moment of failure? A nightly backup leaves up to 24 hours of writes exposed; an hourly incremental leaves one. In one recent incident a script missing its WHERE clause cost 12,000 shipment updates - that gap was the entire damage. TimeTravel keeps the gap at seconds, so a rollback loses the bad write instead of the good ones around it.

Three: Change Attribution Coverage

Take a random sample of twenty rows changed in the last week and ask who changed each one, in which release, against which ticket. Most teams trace three to six of them. The rest came from a backfill, a support fix, or an ad-hoc script that ran once and was never mentioned again. Per-row history with an actor attached turns that sample into twenty out of twenty.

Four: Evidence Turnaround

How many working hours does one auditor or incident-review question cost? Prove the pricing table was correct on 3 March. Show that nothing was edited after the fact. Reconstruct the system as it stood when the incident began. If the answer is a restore plus a spreadsheet, count a day. If the answer is a query against captured history, count minutes.

Five: Change Review Coverage

What share of statements that touch production data passed review before they ran? Schema migrations usually do. Manual updates, hotfix scripts and one-off cleanups usually do not - and those are precisely the statements that cause incidents. Recording every change produces a reviewable log even for the work that skipped the process.

What the Numbers Looked Like for One Team

A mid-sized distributor ran this exercise before committing to anything. Their baseline: restore lead time three hours forty minutes, recovery point gap eleven hours, attribution coverage four rows out of twenty, evidence turnaround a full working day, review coverage about half of all data changes.

Four months after moving recovery from nightly backups to continuous capture, the same five numbers read: nine minutes, eight seconds, twenty out of twenty, under an hour, and a queryable change log. Nothing in their application changed. The number that moved the business most was not the fastest one - it was attribution, because support stopped escalating data questions to engineering.

🔮

The first number to fix is the one that ends incidents

Restore lead time and recovery point gap decide how much an incident costs. Attribution coverage decides how long it takes to find the cause.

What Has to Be True for Those Numbers to Move

Four requirements follow directly from the metrics. Skip any one of them and the corresponding number stalls.

  • Second-level capture: the recovery point gap only closes if changes are recorded continuously rather than on a schedule.
  • Actor and context on every change: attribution needs the user, session or job behind a write, not just the timestamp.
  • Cheap isolated branches: restore lead time improves for investigations only when a full copy costs seconds instead of hours.
  • Policy-driven retention: evidence turnaround stays low only if history reaches back as far as your audits do.

TimeTravel was built around those four requirements, which is why these are the numbers that move first after installation. Branches are copies you can discard; history is queryable rather than restorable; retention is a setting rather than an archive project.

Measuring Your Own Baseline This Week

  1. Pick a question your team answered twice this quarter - usually state-on-a-date or who-changed-this - and time the honest answer.
  2. Sample twenty changed rows and count how many you can attribute to a person, a release and a ticket.
  3. Ask your DBA for the worst gap between last backup and failure over the last ninety days.
  4. Write all five numbers on one page with today's date, and keep that page for the next incident review.

Objections Worth Taking Seriously

  • Our backups are fine: they are fine for disaster recovery, a different question. A backup restores a whole system to one instant; it cannot show what changed between two.
  • This is just audit logging: logs record statements. They do not restore rows, and they rarely keep the before-image of a record. Version control has to do both.
  • Our database is too large to copy: copy-on-write branching and incremental capture are the answer to that objection; a full physical copy is the method being replaced.
  • We already have change management: then your schema is covered and your data is not. One afternoon of sampling review coverage will show the difference.

Key Takeaways

What to remember

  • Git versions the schema and stops there; five measurable numbers describe what it leaves behind.
  • Restore lead time and recovery point gap decide what an incident costs.
  • Attribution coverage is the number support teams feel first.
  • Baseline your own numbers before choosing a tool; their direction tells you what to fix.

Ready to transform your workflow?

Book a free 15-minute demo and see how TimeTravel works for your business.

Book a Free Demo